1.ElasticSearch

1.什么是RestFul?

因为ElasticSearch中全部遵循RestFul风格,先来说说什么是RestFuk风格

RestFul
- RestFul是一种软件架构风格
- 一个架构的设计如果遵循Rest原则,那么就称这个架构为RestFul风格
Rest
- 全称:资源表现层状态转化(Resource Representational State Transfer), 设计原则,设计约束,设计思路,设计约定....
- 资源(Resource):把网络中的一切事物统称为资源,每一个资源都存在一个唯一的资源标识符(URL),比如一首歌,一张图片,静态页面,数据库记录...
- 表现层(Representational):把资源具体呈现出来的形式称为表现层
- 状态转化(State Transfer):当资源以某种表现形式展现出来的时候,客户端通过操作该资源使资源发生某种变化称为状态妆化

当资源在网络中展现出来的时候,我们都需要在网络中去定位他,定位这个资源就需要一个唯一的资源定位符,这个定位符就是URL;所以上面也说到了可以把网络中的一切称为资源

原则:
- 1.原则1:使用Rest的URL去替换传统的URL;
  - 传统URL: http://localhost:8989/项目名/user/findById?id=123(问号以前的字符才能算URL,问号后面的属于你给url绑定的参数,所以这个url不是唯一的)
  - Rest的URL: http://localhost:8989/项目名/user/findById/123/(将参数与URL融为一体,做到真正的唯一)
- 2.原则2:四个动词对应服务端的四种操作(CRUD)
  - 传统的请求方式只有get和post,让这两个去对应CRUD,在这个时候,请求只有走到数据库了才知道具体是什么操作
  - Rest请求方式,为了让客户端在请求的时候就知道具体是什么操作
    - get(查询)
    - post(更新或添加)
    - put(添加或更新)
    - delete(删除)
    - 备注:当不适用第三方框架的时候,比如SpringMVC,SpringBoot,浏览器现在也只支持get,post

2.什么是全文检索

全文检索是计算机程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置。当用户查询时根据建立的索引查找，类似于通过字典的检索字表查字的过程。
检索: 索(建立索引) 检:(检索索引)
全文检索（Full-Text Retrieval(检索)）以文本作为检索对象，找出含有指定词汇的文本。全面、准确和快速是衡量全文检索系统的关键指标。
关于全文检索，我们要知道：
1. 只处理文本。
2. 不处理语义。处理语义就要上升到人工智能了
3. 搜索时英文不区分大小写。
4. 结果列表有相关度排序。

3. 什么是ElasticSearch

ElasticSearch 简称 ES ，是基于Apache Lucene构建的开源搜索引擎，是当前流行的企业级搜索引擎。Lucene本身就可以被认为迄今为止性能最好的一款开源搜索引擎工具包，但是lucene的API相对复杂，需要深厚的搜索理论。很难集成到实际的应用中去。但是ES是采用java语言编写，提供了简单易用的RestFul API，开发者可以使用其简单的RestFul API，开发相关的搜索功能，从而避免lucene的复杂性。

4. ES的诞生

多年前，一个叫做Shay Banon的刚结婚不久的失业开发者，由于妻子要去伦敦学习厨师，他便跟着也去了。在他找工作的过程中，为了给妻子构建一个食谱的搜索引擎，他开始构建一个早期版本的Lucene。
直接基于Lucene工作会比较困难，所以Shay开始抽象Lucene代码以便Java程序员可以在应用中添加搜索功能。他发布了他的第一个开源项目，叫做“Compass”。
后来Shay找到一份工作，这份工作处在高性能和内存数据网格的分布式环境中，因此高性能的、实时的、分布式的搜索引擎也是理所当然需要的。然后他决定重写Compass库使其成为一个独立的服务叫做Elasticsearch。
第一个公开版本出现在2010年2月，在那之后Elasticsearch已经成为Github上最受欢迎的项目之一，代码贡献者超过300人。一家主营Elasticsearch的公司就此成立，他们一边提供商业支持一边开发新功能，不过Elasticsearch将永远开源且对所有人可用。
Shay的妻子依旧等待着她的食谱搜索……

官网:https://www.elastic.co/cn/

5. ES的应用场景

ES主要以轻量级JSON作为数据存储格式，这点与MongoDB有点类似，但它在读写性能上优于 MongoDB 。同时也支持地理位置查询，还方便地理位置和文本混合查询。以及在统计、日志类数据存储和分析、可视化这方面是引领者。

国外:
Wikipedia(维基百科)使用ES提供全文搜索并高亮关键字、StackOverflow(IT问答网站)结合全文搜索与地理位置查询、Github使用Elasticsearch检索1300亿行的代码。
国内:
百度(在云分析、网盟、预测、文库、钱包、风控等业务上都应用了ES，单集群每天导入30TB+数据，总共每天60TB+)、新浪、阿里巴巴、腾讯等公司均有对ES的使用。
使用比较广泛的平台ELK(ElasticSearch, Logstash, Kibana)。

6. ES的安装

6.1 准备环境

# 0.安装前准备
- centos7 +
- java 8  +
- elastic 6.8.0+

# 1.在官方网站下载ES
- wget http://artifacts.elastic.co/downloads/elasticsearch/elasticsearch-6.8.0.tar.gz

# 2.安装JDK(必须JDK1.8+)
- rpm -ivh jdk-8u181-linux-x64.rpm
	/*注意:默认安装位置 /usr/java/jdk1.8.0_171-amd64*/

# 3.配置环境变量
- vim /etc/profile
	在文件末尾加入:
	export JAVA_HOME=/usr/java/jdk1.8.0_171-amd64
	export PATH=$PATH:$JAVA_HOME/bin

# 4.重载系统配置
- source /etc/profile

安装JDK,也可以使用yum直接安装
1.查看是否已安装JDK
# yum list installed |grep java

2.卸载CentOS系统Java环境
# yum -y remove java-1.8.0-openjdk*   *表示卸载所有openjdk相关文件输入 
# yum -y remove tzdata-java.noarch       卸载tzdata-java  

3.查看JDK软件包版本
# yum -y list java*      或者使用# yum searchjava | grep -i --color JDK 
查看JDK软件包列表

安装JDK
# yum install java-1.8.0-openjdk*  安装java1.8.0所有程序 
yum install -y java-1.8.0-openjdk-devel.x86_64
注意:输入确认(y)直到控制台返回Complete安装成功

查看java版本信息
# java -version

输入javac    java命令后显示帮助信息就算是安装成功了
使用yum安装环境变量自动就配好了

6.2 安装ES服务

# 1. ES不能以root用户身份启动必须创建普通用户
- a.在linux系统中创建新的组
		groupadd es
- b.创建新的用户es并将es用户放入es组中
		useradd es -g es 
- c.修改es用户密码
		passwd es

# 2.使用普通用户登录并上传安装包

# 3.解压缩elasticsearch
- tar -zxvf elasticsearch-6.4.1.tar.gz

# 4.进入ES安装目录查看目录结构
- bin                         可执行的二进制文件的目录
- config                      配置文件的目录
- lib                         运行时依赖的库
- logs         		      运行时日志文件
- modules		      运行时依赖的模块
- plugins                     可以安装官方以及第三方插件

# 5.进入bin目录中启动ES服务
- ./elasticsearch
- 出现下图红色日志说明启动成功:

# 6.执行如下命令测试客户端操作
- curl http://localhost:9200

注:es默认有两个端口号,9200作为Http协议,主要用于外部通讯 ,9300作为Tcp协议,jar之间就是通过tcp协议通讯 ES集群之间是通过9300进行通讯

6.3开启远程连接权限

注意:ES服务默认启动是受保护的,只允许本地客户端连接,如果想要通过远程客户端访问,必须开启远程连接

# 1.开启ES远程访问
- vim elasticsearch.yml 将原来network修改为以下配置:
	network.host: 0.0.0.0

原始配置
修改后配置

# 2.重启启动ES服务
- [es@localhost bin]$ ./elasticsearch

# 3.重新启动es出现如下错误
- ERROR: [3] bootstrap checks failed
	[1]: max file descriptors [4096] for elasticsearch process is too low, increase to at least [65535]
	[2]: max number of threads [3802] for user [es] is too low, increase to at least [4096]
	[3]: max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

# 4.解决错误[1] 使用root用户修改系统配置
- vim /etc/security/limits.conf	 在最后面追加下面内容
	*               soft    nofile          65536
	*               hard    nofile          65536
	*               soft    nproc           4096
	*               hard    nproc           4096

# 5.登录重新在检测配置是否生效(一定要重新登录)
- ulimit -Hn
  ulimit -Sn
  ulimit -Hu
  ulimit -Su

# 6.解决错误[2]  使用root用户修改系统配置
- vim /etc/security/limits.d/20-nproc.conf 
	启动ES用户名 soft nproc 4096

# 7.解决错误[3] 使用root用户修改系统配置
- vim /etc/sysctl.conf
	vm.max_map_count=655360

# 8.执行如下命令检测是否生效
- sysctl -p

# 9.退出从新登录之后重新启动ES服务
- [es@localhost bin]$ ./elasticsearch

# 10.通过浏览器访问ES服务
- http://192.168.8.129:9200/

11.访问失败,关闭Linux的防火墙
systemctl stop firewalld  关闭防火墙
systemctl start firewalld 打开防火墙
systemctl status firewalld  查看状态

12.访问成功

7.ES中的基本概念

7.1 接近实时(NRT Near Real Time )

Elasticsearch是一个接近实时的搜索平台。这意味着，从索引一个文档直到这个文档能够被搜索到有一个轻微的延迟(通常是1秒内)

7.2 索引(index)

一个索引就是一个拥有几分相似特征的文档的集合。比如说，你可以有一个客户数据的索引，另一个产品目录的索引，还有一个订单数据的索引。一个索引由一个名字来标识(必须全部是小写字母的)，并且当我们要对这个索引中的文档进行索引、搜索、更新和删除的时候，都要使用到这个名字。索引类似于关系型数据库中Database 的概念。在一个集群中，如果你想，可以定义任意多的索引。

7.3 类型(type)

在一个索引中，你可以定义一种或多种类型。一个类型是你的索引的一个逻辑上的分类/分区，其语义完全由你来定。通常，会为具有一组共同字段的文档定义一个类型。比如说，我们假设你运营一个博客平台并且将你所有的数据存储到一个索引中。在这个索引中，你可以为用户数据定义一个类型，为博客数据定义另一个类型，当然，也可以为评论数据定义另一个类型。类型类似于关系型数据库中Table的概念。

NOTE: 在5.x版本以前可以在一个索引中定义多个类型,6.x之后版本也可以使用,但是不推荐,在7~8.x版本中彻底移除一个索引中创建多个类型

7.4 映射(Mapping)

Mapping是ES中的一个很重要的内容，它类似于传统关系型数据中table的schema，用于定义一个索引(index)中的类型(type)的数据的结构。在ES中，我们可以手动创建type(相当于table)和mapping(相关与schema),也可以采用默认创建方式。在默认配置下，ES可以根据插入的数据自动地创建type及其mapping。 mapping中主要包括字段名、字段数据类型和字段索引类型

7.5 文档(document)

一个文档是一个可被索引的基础信息单元，类似于表中的一条记录。比如，你可以拥有某一个员工的文档,也可以拥有某个商品的一个文档。文档以采用了轻量级的数据交换格式JSON(Javascript Object Notation)来表示。

7.6 概念关系图

7.7 Es中5版本过度到6版本的比较大的变化

上面讲到的是5版本的模型,在5.x版本以前可以在一个索引中定义多个类型,在6版本中可以正常工作,在7版本中,类型将被弃用,在8版本中,则背完全移除,之后一个索引中只能存储一种类型,在官方文档中也给出了相应的解释,说之前把一个索引比如一个数据库是一个错误的比喻,因为一个索引中,不同类型的字段中,具有相同名称的字段会出现问题

8. Kibana的安装

Kibana是一个针对Elasticsearch的开源分析及可视化平台，使用Kibana可以查询、查看并与存储在ES索引的数据进行交互操作，使用Kibana能执行高级的数据分析，并能以图表、表格和地图的形式查看数据。主要用来对es的数据做可视化,我们今天主要用他的dev tools来做对es的数据操作
kibaan和es的版本必须严格一直

root用户
# 1.下载Kibana
- https://www.elastic.co/downloads/kibana

# 2. 安装下载的kibana
- rpm -ivh kibana-6.2.4-x86_64.rpm

# 3. 查找kibana的安装位置
- find / -name kibana
    
# 4. 编辑kibana配置文件
- [root@localhost /]# vim /etc/kibana/kibana.yml

# 5. 修改如下配置
- server.host: "192.168.8.129"                				 #ES服务器主机地址
- elasticsearch.hosts: ["http://192.168.8.129:9200"]   #ES服务器地址

# 6. 启动kibana
- systemctl start kibana
	systemctl stop  kibana
	systemctl status kibana

# 7. 访问kibana的web界面  
- http://192.168.8.129:5601/   #kibana默认端口为5601 使用主机:端口直接访问即可

9. Kibana的基本操作(dev tools)

9.1 索引(Index)的基本操作

PUT /dangdang/       	  	创建索引
DELETE /dangdang		删除索引
DELETE /*			删除所有索引
GET /_cat/indices?v 		查看索引信息

9.2 类型(type)的基本操作

创建类型

1.创建/dangdang索引并创建(product)类型
PUT /dangdang             
{
  "mappings": {
    "product": {
      "properties": {
        	"title":    { "type": "text"  },
        	"name":     { "type": "text"  },
       		"age":      { "type": "integer" },
        	"created":  {
         		 "type":   "date"
        		}
      		}
    	}
  	}
}
注意: 这种方式创建类型要求索引不能存在

Mapping Type: : text , keyword , date ,integer, long , double , boolean or ip

查看类型

GET /dangdang/_mapping/product # 语法:GET /索引名/_mapping/类型名

9.3 文档(document)的基本操作(就相当于一条数据)

添加文档

PUT /ems/emp/1   #/索引/类型/id
{
  "name":"赵小六",
  "age":23,
  "bir":"2012-12-12",
  "content":"这是一个好一点的员工"
}

若需要系统帮我们生成id,需要使用post

POST /ems/emp
{
  "name":"赵小六2",
  "age":25,
  "bir":"2012-11-11",
  "content":"这是一个"
}

查询文档

GET /ems/emp/1  
返回结果:
{
  "_index": "ems",
  "_type": "emp",
  "_id": "1",
  "_version": 1,
  "found": true,
  "_source": {
    "name": "赵小六",
    "age": 23,
    "bir": "2012-12-12",
    "content": "这是一个好一点的员工"
  }
}

删除文档

DELETE /ems/emp/1
{
  "_index": "ems",
  "_type": "emp",
  "_id": "1",
  "_version": 2,
  "result": "deleted", #删除成功
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 1,
  "_primary_term": 1
}

更新文档

    1.第一种方式  更新原有的数据
        POST /ems/emp/1/_update
        {
          "doc":{
            "name":"xiaohei"
          }
        }
    2.第二种方式  添加新的数据,并跟新
        POST /ems/emp/1/_update
        {
          "doc":{
            "name":"xiaohei",
            "age":11,
            "dpet":"你好部门"
          }
        }
    3.第三种方式 在原来数据基础上更新
    	POST /ems/emp/1/_update
        {
          "script": "ctx._source.age += 5"
        }
    4.删除原来的数据,添加新数据,会丢失原来的数据
        POST /ems/emp/1
        {
          "name":"123"
        }

    ES的使用语法风格为:
    <REST Verb> /<Index>/<Type>/<ID>
    REST操作    /索引/类型/文档id

批量操作 _bulk

关键字

添加:index
删除:delete
更新:update

PUT /ems/emp/_bulk
		{"update":{"_id":"1"}}
			{"doc":{"name":"lisi"}}
		{"delete":{"_id":2}}
		{"index":{"_id":"1"}}
			{"name":"xxx","age":23}

注意:批量时不会因为一个失败而全部失败,而是继续执行后续操作,批量在返回时按照执行的状态开始返回

10. ES中高级检索(Query)

10.1 检索方式 _search

索:创建索引检:查询索引
ES官方提供了两中检索方式:一种是通过 URL 参数进行搜索,另一种是通过 DSL(Domain Specified Language) 进行搜索。官方更推荐使用第二种方式第二种方式是基于传递JSON作为请求体(request body)格式与ES进行交互，这种方式更强大，更简洁。

使用语法
URL查询: GET /索引/类型/_search?参数
DSL查询: GET /索引/类型/_search {}

10.2 测试数据

    1.删除索引

    DELETE /ems
    2.创建索引并指定类型
    PUT /ems
    {
      "mappings":{
        "emp":{
          "properties":{
            "name":{
              "type":"text"
            },
            "age":{
              "type":"integer"
            },
            "bir":{
              "type":"date"
            },
            "content":{
              "type":"text"
            },
            "address":{
              "type":"keyword"
            }
          }
        }
      }
    }
    
    3.插入测试数据
    PUT /ems/emp/_bulk
      {"index":{}}
      {"name":"小黑","age":23,"bir":"2012-12-12","content":"为开发团队选择一款优秀的MVC框架是件难事儿，在众多可行的方案中决择需要很高的经验和水平","address":"北京"}
      {"index":{}}
      {"name":"王小黑","age":24,"bir":"2012-12-12","content":"Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式","address":"上海"}
      {"index":{}}
      {"name":"张小五","age":8,"bir":"2012-12-12","content":"Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善","address":"无锡"}
      {"index":{}}
      {"name":"win7","age":9,"bir":"2012-12-12","content":"Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？","address":"南京"}
      {"index":{}}
      {"name":"梅超风","age":43,"bir":"2012-12-12","content":"Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API","address":"杭州"}
      {"index":{}}
      {"name":"张无忌","age":59,"bir":"2012-12-12","content":"ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口","address":"北京"}

10.2 URL检索(了解即可)

GET /ems/emp/_search?q=*&sort=age:asc

_search 搜索的API
q=* 匹配所有文档
sort 以结果中的指定字段排序

GET /ems/emp/search?q=*&sort=age:desc&size=5&from=0&source=name,age,bir

10.3 DSL检索(必须掌握)

NOTE: 以下重点讲解DSL语法,基于requestbody请求体

    GET /ems/emp/_search
    {
        "query": {"match_all": {}},       //查询所有
        "sort": [                         //排序 
            {
                "age": {
                    "order": "desc"
                }
            }
        ]
    }

10.4 DSL高级检索(Query)

0. 查询所有(match_all)

match_all关键字: 返回索引中的全部文档

GET /ems/emp/_search
{
 	"query": { "match_all": {} }
}

1. 查询结果中返回指定条数(size)

size 关键字: 指定查询结果中返回指定条数。默认返回值10条

GET /ems/emp/_search
{
 	"query": { "match_all": {} },
	"size": 1
}

2. 分页查询(from)

from 关键字: 用来指定起始返回位置，和size关键字连用可实现分页效果

GET /ems/emp/_search
{
      "query": {"match_all": {}},
      "sort": [
        {
          "age": {
            "order": "desc"
          }
        }
      ],
      "size": 2, 
      "from": 1
}

3. 查询结果中返回指定字段(_source)

_source 关键字: 是一个数组,在数组中用来指定展示那些字段

GET /ems/emp/_search
{
      "query": { "match_all": {} },
      "_source": ["account_number", "balance"]
}

4. 关键词查询(term)

term 关键字: 用来使用关键词查询

GET /ems/emp/_search
{
  "query": {
    "term": {
      "address": {
        "value": "北京"
      }
    }
  }
}

NOTE1: 通过使用term查询得知ES中默认使用分词器为标准分词器(StandardAnalyzer),标准分词器对于英文以单词分词,对于中文以单字分词。
NOTE2: 通过使用term查询得知,在ES的Mapping Type 中 keyword , date ,integer, long , double , boolean or ip 这些类型不分词，只有text类型分词。
NOTE3: 关键字必须全部小写,因为分词器已经默认分为小写了

5. 范围查询(range)

range 关键字: 用来指定查询指定范围内的文档
gte 大于等于 gt 大于 lte 小于等于 lt小于

    GET /ems/emp/_search
    {
      "query": {
        "range": {
          "age": {
            "gte": 8,
            "lte": 30
          }
        }
      }
    }

6. 前缀查询(prefix)

prefix 关键字: 用来检索含有指定前缀的关键词的相关文档,大写查不出来

GET /ems/emp/_search
{
  "query": {
    "prefix": {
      "content": {
        "value": "redis"
      }
    }
  }
}

7. 通配符查询(wildcard)

wildcard 关键字: 通配符查询 ? 用来匹配一个任意字符 * 用来匹配多个任意字符

GET /ems/emp/_search
{
  "query": {
    "wildcard": {
      "content": {
        "value": "re*"
      }
    }
  }
}

8. 多id查询(ids)

ids 关键字 : 值为数组类型,用来根据一组id获取多个对应的文档

    GET  /ems/emp/_search
    {
      "query": {
        "ids": {
          "values": ["lg5HwWkBxH7z6xax7W3_","lQ5HwWkBxH7z6xax7W3_"]
        }
      }
    }

9. 模糊查询(fuzzy)

fuzzy 关键字: 用来模糊查询含有指定关键字的文档

    GET /ems/emp/_search
    {
      "query": {
        "fuzzy": {
          "content":"spring"
        }
      }
    }
    fuzzy 模糊查询  最大模糊错误 必须在0-2之间
    # 搜索关键词长度为 2 不允许存在模糊 0
    # 搜索关键词长度为3-5 允许一次模糊 0 1 
    # 搜索关键词长度大于5 允许最大2模糊

10. 布尔查询(bool)

bool 关键字: 用来组合多个条件实现复杂查询

must: 相当于&& 同时成立

should: 相当于|| 成立一个就行

must_not: 相当于!  不能满足任何一个

    GET /ems/emp/_search
    {
      "query": {
        "bool": {
          "must": [
            {
              "range": {
                "age": {
                  "gte": 0,
                  "lte": 30
                }
              }
            }
          ],
          "must_not": [
            {"wildcard": {
              "content": {
                "value": "redi?"
              }
            }}
          ]
        }
      },
      "sort": [
        {
          "age": {
            "order": "desc"
          }
        }
      ]
    }

11. 高亮查询(highlight)

highlight 关键字: 可以让符合条件的文档中的关键词高亮

    GET /ems/emp/_search
    {
      "query": {
        "term": {
          "content": {
            "value": "redis"
          }
        }
      },
      "highlight": {
        "fields": {
          "*": {}
        }
      }
    }

自定义高亮html标签: 可以在highlight中使用pre_tags和post_tags

    GET /ems/emp/_search
    {
      "query":{
        "term":{
          "content":"框架"
        }
      },
      "highlight": {
        "pre_tags": ["<span style='color:red'>"],
        "post_tags": ["</span>"],
        "fields": {
          "*":{}
        }
      }
    }

多字段高亮使用require_field_match开启多个字段高亮,如果不写,es为了效率,只会默认content字段高亮

     GET /ems/emp/_search
    {
      "query":{
        "term":{
          "content":"框架"
        }
      },
      "highlight": {
        "pre_tags": ["<span style='color:red'>"],
        "post_tags": ["</span>"],
        "require_field_match":false,
        "fields": {
          "*":{}
        }
      }
    }

12. 多字段查询(multi_match)

1.如果搜索的字段分词,他会对query进行先分词,在搜索

2.如果搜索的字段不分词,他会直接使用query整体进行该字段分词

    GET /ems/emp/_search
    {
      "query": {
        "multi_match": {
          "query": "中国",
          "fields": ["name","content"] #这里写要检索的指定字段
        }
      }
    }

13. 多字段分词查询(query_string)

可以指定分词器

    GET /dangdang/book/_search
    {
      "query": {
        "query_string": {
          "query": "中国声音",
          "analyzer": "ik_max_word", 
          "fields": ["name","content"]
        }
      }
    }

更多操作自行查看官方文档:https://www.elastic.co/guide/en/elasticsearch/reference/6.8/release-notes-6.8.11.html

11. IK分词器

NOTE: 默认ES中采用标准分词器进行分词,这种方式并不适用于中文网站,因此需要修改ES对中文友好分词,从而达到更佳的搜索的效果。

11.1 在线安装IK

在线安装IK (v5.5.1版本后开始支持在线安装 )

    # 0.必须将es服务中原始数据删除
    - 进入es安装目录中将data目录数据删除
    	rm -rf data
    
注意:安装前一定要先jps查看es的进程,然后 kill 杀死进程,在安装分词器,否则安装完之后es的初始索引会变红
    # 1. 在es安装目录中执行如下命令
    
    [es@linux elasticsearch-6.2.4]$ ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.0/elasticsearch-analysis-ik-6.8.0.zip
    -> Downloading https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.2.4/elasticsearch-analysis-ik-6.2.4.zip
    [=================================================] 100%
    -> Installed analysis-ik
    [es@linux elasticsearch-6.2.4]$ ls plugins/
    analysis-ik
    [es@linux elasticsearch-6.2.4]$ cd plugins/analysis-ik/
    [es@linux analysis-ik]$ ls
    commons-codec-1.9.jar    elasticsearch-analysis-ik-6.2.4.jar  httpcore-4.4.4.jar
    commons-logging-1.2.jar  httpclient-4.5.2.jar                 plugin-descriptor.properties
    
    
    # 2. 重启es生效
    
    # 3.测试ik安装成功
    两种形式
    GET /_analyze
    {
      "text": "中华人民共和国国歌",
      "analyzer": "ik_smart"
    }
    
    GET /_analyze
    {
      "text": "中华人民共和国国歌", 
       "analyzer": "ik_max_word"
    }


    # 4.在线安装IK配置文件 
    - es安装目录中config目录analysis-ik/IKAnalyzer.cfg.xml

NOTE: 要求版本严格与当前使用版本一致,如需使用其他版本替换 6.2.4 为使用的版本号

11.2 本地安装IK

可以将对应的IK分词器下载到本地,然后再安装

    # 1. 下载对应版本
    - [es@linux ~]$ wget https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.2.4/elasticsearch-analysis-ik-6.2.4.zip
    
    # 2. 解压
    - [es@linux ~]$ unzip elasticsearch-analysis-ik-6.2.4.zip #先使用yum install -y unzip
    
    # 3. 移动到es安装目录的plugins目录中
    - [es@linux ~]$ ls elasticsearch-6.2.4/plugins/
    	[es@linux ~]$ mv elasticsearch elasticsearch-6.2.4/plugins/
    	[es@linux ~]$ ls elasticsearch-6.2.4/plugins/
    		elasticsearch
    	[es@linux ~]$ ls elasticsearch-6.2.4/plugins/elasticsearch/
    		commons-codec-1.9.jar    config                               httpclient-4.5.2.jar  		plugin-descriptor.properties
    		commons-logging-1.2.jar  elasticsearch-analysis-ik-6.2.4.jar  httpcore-4.4.4.jar
    		
    # 4. 重启es生效
    
    # 5. 本地安装ik配置目录为  
    - es安装目录中/plugins/analysis-ik/config/IKAnalyzer.cfg.xml

11.3 测试IK分词器

NOTE: IK分词器提供了两种mapping类型用来做文档的分词分别是 ik_max_word 和ik_smart
ik_max_word 和 ik_smart 什么区别?
ik_max_word: 会将文本做最细粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,中华人民,中华,华人,人民共和国,人民,人,民,共和国,共和,和,国国,国歌”，会穷尽各种可能的组合；
ik_smart: 会做最粗粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,国歌”。

测试数据(ik分词器,有两种拆分形式,所以在创建索引的时候可以指定分词器类型,不指定,就默认标准分词器)

analyzer:指定添加数据的时候应该使用什么样的分词器
search_analyzer:使用关键词搜索的时候,应该使用什么样的分词器
建立索引的分词器必须和搜索的分词器严格一致

DELETE /ems

PUT /ems
{
  "mappings":{
    "emp":{
      "properties":{
        "name":{
          "type":"text",
           "analyzer": "ik_max_word",
           "search_analyzer": "ik_max_word"
        },
        "age":{
          "type":"integer"
        },
        "bir":{
          "type":"date"
        },
        "content":{
          "type":"text",
          "analyzer": "ik_max_word",
          "search_analyzer": "ik_max_word"
        },
        "address":{
          "type":"keyword"
        }
      }
    }
  }
}

PUT /ems/emp/_bulk
  {"index":{}}
  {"name":"小黑","age":23,"bir":"2012-12-12","content":"为开发团队选择一款优秀的MVC框架是件难事儿，在众多可行的方案中决择需要很高的经验和水平","address":"北京"}
  {"index":{}}
  {"name":"王小黑","age":24,"bir":"2012-12-12","content":"Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式","address":"上海"}
  {"index":{}}
  {"name":"张小五","age":8,"bir":"2012-12-12","content":"Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善","address":"无锡"}
  {"index":{}}
  {"name":"win7","age":9,"bir":"2012-12-12","content":"Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？","address":"南京"}
  {"index":{}}
  {"name":"梅超风","age":43,"bir":"2012-12-12","content":"Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API","address":"杭州"}
  {"index":{}}
  {"name":"张无忌","age":59,"bir":"2012-12-12","content":"ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口","address":"北京"}


GET /ems/emp/_search
{
  "query":{
    "term":{
      "content":"框架"
    }
  },
  "highlight": {
    "pre_tags": ["<span style='color:red'>"],
    "post_tags": ["</span>"],
    "fields": {
      "*":{}
    }
  }
}

11.4 配置扩展词

es已经做的非常智能了,能够将以前的所有词都录入到库中,但是随着网络的发展,不断出现的网络红词,分词器是做不到的,比如蓝瘦,杠精等等这些词语都是查不到的,所以这个时候我们就需要自己来配置一下分词器

IK支持自定义扩展词典和停用词典,所谓扩展词典就是有些词并不是关键词,但是也希望被ES用来作为检索的关键词,可以将这些词加入扩展词典。停用词典就是有些词是关键词,但是出于业务场景不想使用这些关键词被检索到，可以将这些词放入停用词典。
如何定义扩展词典和停用词典可以修改IK分词器中config目录中IKAnalyzer.cfg.xml这个文件。

NOTE：词典的编码必须为UTF-8，否则无法生效

**本地安装和在线安装的ik分词器的配置文件所在位置是不一样的,在线安装的配置文件路径elasticsearch-6.8.0/config/analysis-ik/,本地安装配置文件的路径:plugins/ik/config/**
1. 修改vim IKAnalyzer.cfg.xml

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE properties SYSTEM "http://java.sun.com/dtd/properties.dtd">
    <properties>
        <comment>IK Analyzer 扩展配置</comment>
        <!--用户可以在这里配置自己的扩展字典 -->
        <entry key="ext_dict">ext_dict.dic</entry>
         <!--用户可以在这里配置自己的扩展停止词字典-->
        <entry key="ext_stopwords">ext_stopword.dic</entry>
    </properties>

2. 在ik分词器目录下config目录中创建ext_dict.dic文件   编码一定要为UTF-8才能生效
	vim ext_dict.dic 加入扩展词即可

3. 在ik分词器目录下config目录中创建ext_stopword.dic文件 
	vim ext_stopword.dic 加入停用词即可

4.重启es生效

11.5配置远程扩展词典和远程停用词典

引言:我们在实际开发中,不会经常去主动搜索热搜词语,然后去手动修改es的本地扩展词典,而是需要动态的使用redis对词语进行定期的计数,然后将达到一定数量的词语写入到一个文本文件,然后让es去动态的读取文件即可

1.创建一个web项目,以ext.txt作为远程词典,这里我们就不模拟redis的动态写入了

2.启动项目,然后使用浏览器访问文本文件,看能否访问的到:http://172.17.0.153:8989/es/ext.txt
3.修改es配置文件地址,填写刚刚浏览器的访问地址即可

4.测试,检索成功
5.当我们往文本文件中添加数据的时候(注意:添加数据的时候必须换行),不用启动项目,等待es自动加载即可(注意:这个时候,之前的数据不会有这个热搜词语,以后加的数据才会有)

12.(过滤查询) Filter Query

12.1 过滤查询

其实准确来说，ES中的查询操作分为2种: 查询(query)和过滤(filter)。查询即是之前提到的query查询，它 (查询)默认会计算每个返回文档的得分，然后根据得分排序。而过滤(filter)只会筛选出符合的文档，并不计算得分，且它可以缓存文档。所以，单从性能考虑，过滤比查询更快。

换句话说，过滤适合在大范围筛选数据，而查询则适合精确匹配数据。一般应用时，应先使用过滤操作过滤数据，然后使用查询匹配数据。

结论:因为filter可以筛选出符合条件的文档,但不计算分数排序,但是可以缓存,所以我们在做查询的时候,先去做filter筛选出符合条件的文档,然后再去使用query查询filter筛选出的数据,在进行计算分数并排序,然后返回给客户端,这样就可以极大的提高查询效率

12.2 过滤语法

GET /ems/emp/_search
{
  "query": {
    "bool": {
      "must": [
        {"match_all": {}}
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 10
          }
        }
      }
    }
  }
}

NOTE: 在执行filter和query时,先执行filter在执行query

NOTE:Elasticsearch会自动缓存经常使用的过滤器，以加快性能。

12.3 常见的过滤器类型

term 、 terms Filter

GET /ems/emp/_search   # 使用term过滤
{
  "query": {
    "bool": {
      "must": [
        {"term": {
          "name": {
            "value": "小黑"
          }
        }}
      ],
      "filter": {
        "term": {
          "content":"框架"
        }
      }
    }
  }
}
GET /dangdang/book/_search  #使用terms过滤
{
  "query": {
    "bool": {
      "must": [
        {"term": {
          "name": {
            "value": "中国"
          }
        }}
      ],
      "filter": {
        "terms": {
          "content":[
              "科技",
              "声音"
            ]
        }
      }
    }
  }
}

ranage filter

GET /ems/emp/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {
          "name": {
            "value": "中国"
          }
        }}
      ],
      "filter": {
        "range": {
          "age": {
            "gte": 7,
            "lte": 20
          }
        }
      }
    }
  }
}

exists filter

过滤存在指定字段,获取字段不为空的索引记录使用

GET /ems/emp/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {
          "name": {
            "value": "中国"
          }
        }}
      ],
      "filter": {
        "exists": {
          "field":"aaa"
        }
      }
    }
  }
}

ids filter

过滤含有指定字段的索引记录

GET /ems/emp/_search
{
  "query": {
    "bool": {
      "must": [
        {"term": {
          "name": {
            "value": "中国"
          }
        }}
      ],
      "filter": {
        "ids": {
          "values": ["1","2","3"]
        }
      }
    }
  }
}

更多操作查看官方文档

13.Java操作ES

比较简单的es实现,当数据量巨大的时候,使用ELK框架,这些理论将不在适用

13.1 引入maven依赖

<dependency>
  <groupId>org.elasticsearch</groupId>
  <artifactId>elasticsearch</artifactId>
  <version>6.8.0</version>
</dependency>
<dependency>
  <groupId>org.elasticsearch.client</groupId>
  <artifactId>transport</artifactId>
  <version>6.8.0</version>
</dependency>
<dependency>
  <groupId>org.elasticsearch.plugin</groupId>
  <artifactId>transport-netty4-client</artifactId>
  <version>6.8.0</version>
</dependency>

13.2创建索引和类型

Rest的创建方式

// 1.在restful的创建方式

PUT /dangdang
{
  "mappings": {
    "book":{
      "properties": {
        "name":{
          "type":"text",
          "analyzer": "ik_max_word"
        },
        "age":{
          "type":"integer"
        },
        "sex":{
          "type":"keyword"
        },
        "content":{
          "type":"text",
          "analyzer": "ik_max_word"
        }
      }
    }
  }
}

0. 创建客户端操作对象

    //创建es客户端操作对象
    @Test
    public void tsetInit() throws UnknownHostException {

        //创建es客户端 是一个抽象类,不能直接new,只能new 他的实现类 (ctrl + t)
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        //设置es操作服务器的主机和端口
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.10.41"),9300));
        //操作

        //释放资源
        transportClient.close();
    }

1. 创建索引(一般情况下,创建索引不会使用java代码,都是在kabnan中定义好,一般用java代码是用来操作文档的)

public class TestIndexAndTypeMapping {

    private TransportClient transportClient;
    @Test
    public void createIndex() throws UnknownHostException {
       this.transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.10.41"),9300));
        //创建索引,必须保证创建的索引不存在
        CreateIndexResponse dangdang = transportClient.admin().indices().prepareCreate("dangdang").get();
        //获取信息
        boolean acknowledged = dangdang.isAcknowledged();
        System.out.println(acknowledged);
        transportClient.close();
    }
}

2. 删除索引

//删除索引
    @Test
    public void deleteIndex() throws UnknownHostException {
        this.transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.10.41"),9300));
        //删除索引
        AcknowledgedResponse dangdang = transportClient.admin().indices().prepareDelete("dangdang").get();
        boolean acknowledged = dangdang.isAcknowledged();
        System.out.println(acknowledged);
        transportClient.close();
    }

3.创建索引和类型

//创建索引 类型 mapping
    @Test
    public void createIndexAndTypeMapping() throws UnknownHostException, ExecutionException, InterruptedException {
        this.transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.10.41"),9300));
        //创建一个索引的请求对象
        CreateIndexRequest dangdang = new CreateIndexRequest("dangdang");

        //索引设置类型
        //参数1:类型名 参数二:映射的json格式 参数3:映射的格式类型
        dangdang.mapping("book","{\n" +
                "      \"properties\": {\n" +
                "        \"name\":{\n" +
                "          \"type\":\"text\",\n" +
                "          \"analyzer\": \"ik_max_word\"\n" +
                "        },\n" +
                "        \"age\":{\n" +
                "          \"type\":\"integer\"\n" +
                "        },\n" +
                "        \"sex\":{\n" +
                "          \"type\":\"keyword\"\n" +
                "        },\n" +
                "        \"content\":{\n" +
                "          \"type\":\"text\",\n" +
                "          \"analyzer\": \"ik_max_word\"\n" +
                "        }\n" +
                "      }\n" +
                "    }", XContentType.JSON);

        //创建索引,必须保证创建的索引不存在
        CreateIndexResponse createIndexResponse = transportClient.admin().indices().create(dangdang).get();
        boolean acknowledged = createIndexResponse.isAcknowledged();
        System.out.println(acknowledged);
        transportClient.close();
    }

13.3 文档的操作

1.指定id文档记录

 //添加一个文档
    @Test
    public void tsetInit() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.10.41"),9300));
        Book book = new Book("1", "在一起", 23, new Date(), "我们在疫情下努力学习!", "北京");
        //转为json放入
        String s = JSONObject.toJSONString(book);
        //索引一条文档
        IndexResponse indexResponse = transportClient.prepareIndex("dangdang", "book", "1").setSource(s, XContentType.JSON).get();
        System.out.println(indexResponse.status());
        transportClient.close();
    }

2.自定生成id文档记录

@Test
    public void tsetInit() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.10.41"),9300));
        Book book = new Book(null,"在一起", 23, new Date(), "我们在疫情下努力学习!", "北京");
        //转为json放入
        String s = JSONObject.toJSONString(book);
        //索引一条文档
        IndexResponse indexResponse = transportClient.prepareIndex("dangdang", "book").setSource(s, XContentType.JSON).get();
        System.out.println(indexResponse.status());
        transportClient.close();
    }

3.更新一条文档

 //更新一条文档
    @Test
    public void tsetupdate() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.10.41"),9300));

        Book book = new Book();
        book.setName("123");
        book.setContent("99999");
        //转为json放入
        String s = JSONObject.toJSONString(book);

        UpdateResponse updateResponse = transportClient.prepareUpdate("dangdang", "book", "1").setDoc(s, XContentType.JSON).get();
        System.out.println(updateResponse.status());
        transportClient.close();
    }

4.删除一条文档

//删除一条文档
    @Test
    public void tsetDelete() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));
        DeleteResponse deleteResponse = transportClient.prepareDelete("dangdang", "book", "1").get();
        System.out.println(deleteResponse.status());
        transportClient.close();
    }

5.查询一条文档

//查询一条文档
    @Test
    public void findById() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));
        GetResponse documentFields = transportClient.prepareGet("dangdang", "book", "1").get();
        System.out.println(documentFields.getSource().toString());
        transportClient.close();
    }

6.各种查询查询所有

//各种查询 查询所有
    @Test
    public void findAll() throws Exception{
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(QueryBuilders.matchAllQuery()).get();
        System.out.println("总条数"+searchResponse.getHits().getTotalHits());
        System.out.println("最大的分"+searchResponse.getHits().getMaxScore());
        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
        transportClient.close();
    }

7.termQuery

 //termQuery
    @Test
    public void term() throws Exception{
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));

        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("content", "学习");

        SearchResponse searchResponse = transportClient.prepareSearch("dangdang")
                .setTypes("book")
                .setQuery(termQueryBuilder)  //查询条件
                .get();
        System.out.println("总条数"+searchResponse.getHits().getTotalHits());
        System.out.println("最大的分"+searchResponse.getHits().getMaxScore());
        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }
        transportClient.close();
    }

8.批量操作

 //批量操作
    @Test
    public void testBulk() throws IOException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));
        Emp emp = new Emp("12","张三丰",23,new Date(),"太极创始人","武当山");
        //添加
        IndexRequest indexRequest = new IndexRequest("ems","emp",emp.getId())
                .source(JSONObject.toJSONStringWithDateFormat(emp,"yyyy-MM-dd"),XContentType.JSON);

        //删除
        DeleteRequest deleteRequest = new DeleteRequest("ems","emp","be78FnMBpzP5KMxRDdbD");

        //修改
        Emp emp1 = new Emp();
        emp1.setContent("Spring 框架是一个分层架构，由 7 个定义良好的模块组成,这是一个开源框架,他非常不错!使用真的很方便");
        UpdateRequest updateRequest = new UpdateRequest("ems", "emp", "bO78FnMBpzP5KMxRDdbD")
                .doc(JSONObject.toJSONString(emp1), XContentType.JSON);
        
        //返回批量更新对象
        BulkRequestBuilder bulkRequestBuilder = transportClient.prepareBulk();
        BulkResponse bulkItemResponses = bulkRequestBuilder
                .add(indexRequest)
                .add(deleteRequest)
                .add(updateRequest)
                .get();

        BulkItemResponse[] items = bulkItemResponses.getItems();
        for (BulkItemResponse item : items) {
            System.out.println(item.status());
        }
        transportClient.close();
    }

13.6 各种查询文档操作

1.查询所有文档

@Test
    public void tsetInit() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));

        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        SearchResponse searchResponse = transportClient.prepareSearch("ems")
                .setTypes("emp")
                .setQuery(matchAllQueryBuilder)
                .get();
        System.out.println("查询总条数"+searchResponse.getHits().totalHits);
        System.out.println("最大得分"+searchResponse.getHits().getMaxScore());
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            System.out.println(hit);
        }
        transportClient.close();
    }

2.查询所有文档并分页排序

 @Test
    public void tsetInit() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));

        MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
        SearchResponse searchResponse = transportClient.prepareSearch("ems")
                .setTypes("emp")
                .setQuery(matchAllQueryBuilder)
                .setFrom(0) //从第一页开始,每页显示两条
                .setSize(2)
                .addSort("age", SortOrder.ASC)
                .get();
        System.out.println("查询总条数"+searchResponse.getHits().totalHits);
        System.out.println("最大得分"+searchResponse.getHits().getMaxScore());
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            System.out.println(hit);
        }
        transportClient.close();
    }

3.返回指定字段

	/**
     *  查询返回指定字段(source) 默认返回所有
     *      setFetchSource 参数1:包含哪些字段   参数2:排除哪些字段
     *      setFetchSource("*","age")  返回所有字段中排除age字段
     *      setFetchSource("name","")  只返回name字段
     *      setFetchSource(new String[]{},new String[]{})
     */
    @Test
    public void testMatchAllQuerySource() throws UnknownHostException {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(QueryBuilders.matchAllQuery()).setFetchSource("*","age").get();
        SearchHits hits = searchResponse.getHits();
        System.out.println("符合条件的记录数: "+hits.totalHits);
        for (SearchHit hit : hits) {
            System.out.print("当前索引的分数: "+hit.getScore());
            System.out.print(", 对应结果:=====>"+hit.getSourceAsString());
            System.out.println(", 指定字段结果:"+hit.getSourceAsMap().get("name"));
            System.out.println("=================================================");
        }
    }

4.term查询

	/**
     *  term查询
     */
    @Test
    public void testTerm() throws UnknownHostException {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
        TermQueryBuilder queryBuilder = QueryBuilders.termQuery("name","中国");
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(queryBuilder).get();
    }

5.range查询

	/**
     *  rang查询
     *     lt    小于
     *     lte   小于等于
     *     gt    大于
     *     gte   大于等于
     */
    @Test
    public void testRange() throws UnknownHostException {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
        RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("age").lt(45).gte(8);
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(rangeQueryBuilder).get();
  	}

6.prefix查询

 	/**
     *  prefix 前缀查询
     *
     */
    @Test
    public void testPrefix() throws UnknownHostException {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
        PrefixQueryBuilder prefixQueryBuilder = QueryBuilders.prefixQuery("name", "中");
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(prefixQueryBuilder).get();
    }

7.wildcard查询

	/**
     *  wildcardQuery 通配符查询
     *
     */
    @Test
    public void testwildcardQuery() throws UnknownHostException {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
        WildcardQueryBuilder wildcardQueryBuilder = QueryBuilders.wildcardQuery("name", "中*");
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(wildcardQueryBuilder).get();
    }

8.ids查询

	/**
     * ids 查询
     */
    @Test
    public void testIds() throws UnknownHostException {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
        IdsQueryBuilder idsQueryBuilder = QueryBuilders.idsQuery().addIds("1","2");
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(idsQueryBuilder).get();
    }

9.fuzzy模糊查询

  	/**
     * fuzzy 查询
     */
    @Test
    public void testFuzzy() throws UnknownHostException {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
        FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("content", "国人");
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(fuzzyQueryBuilder).get();
    }

10.bool查询

  	/**
     * bool 查询
     */
    @Test
    public void testBool() throws UnknownHostException {
        TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName("172.16.251.142"), 9300));
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            boolQueryBuilder.should(QueryBuilders.matchAllQuery());
            boolQueryBuilder.mustNot(QueryBuilders.rangeQuery("age").lte(8));
            boolQueryBuilder.must(QueryBuilders.termQuery("name","中国"));
        SearchResponse searchResponse = transportClient.prepareSearch("dangdang").setTypes("book").setQuery(boolQueryBuilder).get();
    }

11.高亮查询

public class TestDocumentHighlightQuery {

    List<Emp> emps = new ArrayList<>();

    //高亮查询
    //高亮原理:查询出高亮的,然后判断出该对象是否有符合条件的高亮,如果有,就直接替换成高亮显示的字段即可,因为es中查询的高亮的返回值分为两部分,一部分原数据,一部分高亮
    @Test
    public void tsetInit() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));

        HighlightBuilder highlightBuilder = new HighlightBuilder().field("*").requireFieldMatch(false).preTags("<span style='clolr:red;'>").postTags("</span>");

        SearchResponse searchResponse = transportClient.prepareSearch("ems")
                .setTypes("emp")
                .setQuery(QueryBuilders.multiMatchQuery("框架", "content", "name"))
                .highlighter(highlightBuilder).get();
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            Emp emp =  new Emp();

            //封装原始结果
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            emp.setId(hit.getId());
            emp.setName(sourceAsMap.get("name").toString());
            emp.setAge(Integer.valueOf(sourceAsMap.get("age").toString()));
            //  emp.setBir(new SimpleDateFormat("yyyy-MM-dd").parse(sourceAsMap.get("bir").toString());
            emp.setContent(sourceAsMap.get("content").toString());
            emp.setAddress(sourceAsMap.get("address").toString());

            //高亮处理
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();

            if(highlightFields.containsKey("name")){
                String nameHigh = highlightFields.get("name").fragments()[0].toString();
                emp.setName(nameHigh);
            }

            if(highlightFields.containsKey("content")){
                String contentHigh = highlightFields.get("content").fragments()[0].toString();
                emp.setContent(contentHigh);
            }
            emps.add(emp);

        }
        //遍历集合
        emps.forEach(emp-> System.out.println(emp));
        transportClient.close();
    }
}

12.过滤查询 filterQuery

//过滤查询  主要用来做查询数据之前,多大量数据精选筛选的
    @Test
    public void tsetInit() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));
        SearchResponse searchResponse = transportClient.prepareSearch("ems")
                .setTypes("emp")
                .setPostFilter(QueryBuilders.rangeQuery("age").gte(0).lte(10)) //过滤
                .setQuery(QueryBuilders.matchAllQuery())
                .get();
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            System.out.println(hit.getSourceAsString());
        }
        transportClient.close();
    }

13.综合案例

@Test
    public void queryAll() throws UnknownHostException {
        TransportClient transportClient  = new PreBuiltTransportClient(Settings.EMPTY);
        transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.8.129"),9300));
        SearchResponse searchResponse = transportClient.prepareSearch("ems")
                .setTypes("emp")
                .setFrom(0)  //分页
                .setSize(20)
                .addSort("age",SortOrder.DESC)  //排序
                .setSource(SearchSourceBuilder.searchSource().fetchSource("*","bir"))  //指定字段
                .setPostFilter(QueryBuilders.rangeQuery("age").gte(0).lte(50))  //过滤出符合条件的字段
                .setQuery(QueryBuilders.multiMatchQuery("框架爱好者","name","content"))  //搜索
                .highlighter(new HighlightBuilder().field("*").requireFieldMatch(false).preTags("<span style='coloe:red;'>").postTags("</span>"))  //高亮
                .get();
        long totalHits = searchResponse.getHits().getTotalHits();
        System.out.println("总条数"+ totalHits);
        for (SearchHit hit : searchResponse.getHits().getHits()) {
            System.out.println(hit.getSourceAsString());
        }
        transportClient.close();
    }

14.SpringBoot Data 操作ES

官方网站:https://spring.io/projects/spring-data-elasticsearch

14.1 引入依赖

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>

14.2 编写配置

在6版本以前,推荐使用transportClient,也就是方式一,在6版本之后官方推荐使用rest客户端,也就是方式二 RestHighLevelClient

方式一

spring:
  data:
    elasticsearch:
      cluster-nodes: 172.16.251.142:9300

方式二

/**
 * date:
 * Author:CDL
 * desc: es配置类
 * version:1.0
 */
@Configuration
public class RestClientConfig extends AbstractElasticsearchConfiguration {

    //这个client用来替换transportClient
    @Override
    @Bean
    public RestHighLevelClient elasticsearchClient() {

        //定义客户端配置对象 因为是rest客户端 所以说9200端口 ,若果是transportClient,走的是tcp接口,应该用9300
        final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
                .connectedTo("192.168.8.129:9200")
                .build();
        //通过restClient对象创建
        return RestClients.create(clientConfiguration).rest();
    }

}

测试restClient

@SpringBootTest
public class TestRestClient {

/**
 * 复杂查询使用,比如高亮,符合条件的查询,但当我们做一些简单的crud的时候,就需要对象转换json去操作es,这个时候,就可以直接使用ElaticSearchRepository接口,就可以不要不用对象转json,json转对象
 * 简单的crud使用ElaticSearchRepository接口,复杂的使用restHighLevelClient
 */
    @Autowired
    private RestHighLevelClient restHighLevelClient;

     //添加文档
    @Test
    public void testAddIndex() throws IOException {
        IndexRequest indexRequest = new IndexRequest("ems","emp","12");
        indexRequest.source("{\"name\":\"小黑\",\"age\":23}", XContentType.JSON);
        IndexResponse indexResponse = restHighLevelClient.index(indexRequest, RequestOptions.DEFAULT);
        System.out.println(indexResponse.status());
    }



    //删除文档
    @Test
    public void testDeleteIndex() throws IOException {

        //参数1: 索引  参数2:类型  参数3:删除id
        DeleteRequest deleteRequest = new DeleteRequest("ems","emp","cO78FnMBpzP5KMxRDdbD");
        DeleteResponse deleteResponse = restHighLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
        System.out.println(deleteResponse.status());
    }


    //更新文档
    @Test
    public void testUpdate() throws IOException {
        UpdateRequest updateRequest = new UpdateRequest("ems","emp","12");
        updateRequest.doc("{\"name\":\"张三\",\"age\":23}",XContentType.JSON);
        UpdateResponse updateResponse = restHighLevelClient.update(updateRequest, RequestOptions.DEFAULT);
        System.out.println(updateResponse.status());
    }

    //批量更新
    @Test
    public void testBulk() throws IOException {
        BulkRequest bulkRequest = new BulkRequest();

        //添加
        IndexRequest request = new IndexRequest("ems","emp","11");
        request.source("{\"name\":\"李四\",\"age\":23}",XContentType.JSON);
        //删除

        //修改
        bulkRequest.add(request);
        BulkResponse bulkResponse = restHighLevelClient.bulk(bulkRequest, RequestOptions.DEFAULT);
        BulkItemResponse[] items = bulkResponse.getItems();
        for (BulkItemResponse item : items) {
            System.out.println(item.status());
        }
    }


    //查询所有
    @Test
    public void testQueryAll() throws IOException {
        SearchRequest searchRequest = new SearchRequest("ems");
        //创建搜索条件
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //查询所有
        searchSourceBuilder.query(QueryBuilders.matchAllQuery());

        searchRequest.types("emp").source(searchSourceBuilder);
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsString());
        }

    }



    @Test
    public void testSearch() throws IOException {
        //创建搜索对象
        SearchRequest searchRequest = new SearchRequest("ems");
        //搜索构建对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();

        searchSourceBuilder.query(QueryBuilders.matchAllQuery())//执行查询条件
                        .from(0)//起始条数
                        .size(20)//每页展示记录
                        .postFilter(QueryBuilders.matchAllQuery()) //过滤条件
                        .sort("age", SortOrder.DESC)//排序
                        .highlighter(new HighlightBuilder().field("*").requireFieldMatch(false));//高亮

        //创建搜索请求
        searchRequest.types("emp").source(searchSourceBuilder);

        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        System.out.println("符合条件的文档总数: "+searchResponse.getHits().getTotalHits());
        System.out.println("符合条件的文档最大得分: "+searchResponse.getHits().getMaxScore());
        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit hit : hits) {
            System.out.println(hit.getSourceAsMap());
        }
    }
}

14.3 编写entity

@Data
/**
 * 在项目启动的时候,就会创建该索引
 * indexName:用来自定这个对象转为json文档存入哪个索引中,要求es服务器中不能存在此索引名,因为这个注解,当我们启动springboot的时候会自动创建ems索引,如果存在此索引,就会报错
 * type:用来自定在当前这个索引下创建的类型名称
 */
@Document(indexName = "ems",type = "emp") //将emp对象映射成文档 会自动转换成json文档 放到ems索引下的emp类型下
public class Emp{

    @Id
    private String id;

    //Field:用在属性上,代表mapping中的一个字段
    @Field(type = FieldType.Text,analyzer ="ik_max_word")
    private String name;
    @Field(type =FieldType.Integer)
    private Integer age;
    @Field(type = FieldType.Date)
    private Date bir;
    @Field(type = FieldType.Text,analyzer ="ik_max_word")
    private String content;
    @Field(type = FieldType.Keyword)
    private String address;
}

@Document: 代表一个文档记录

`indexName`:  用来指定索引名称
`type`:		用来指定索引类型

@Id: 用来将对象中id和ES中_id映射
@Field: 用来指定ES中的字段对应Mapping

`type`: 用来指定ES中存储类型
`analyzer`: 用来指定使用哪种分词器

14.4 编写BookRepository

/**
 * date:
 * Author:CDL
 * desc: 自定义emp的Respository
 * version:1.0
 */
public interface EmpRespository extends ElasticsearchRepository<Emp,String> {


}

14.5 添加或更新一条记录(当传入的id存在则更新,不存在则添加,当跟新的时候,必须把原始的值都穿入,否则跟新之后,就会变为空)

@Autowired
    private EmpRespository empRespository;

    //当EmpRespository实现了ElasticsearchRepository接口之后,就不用再去对象转json,json转对象了
    @Test
    public void testSave(){
        Emp s = new Emp();
        s.setId(UUID.randomUUID().toString());
        s.setName("张三丰");
        s.setAge(30);
        s.setBir(new Date());
        s.setContent("武当山");
        s.setAddress("武侠大师,一身创建多种武功,太极,武当剑法.....");
        empRespository.save(s);
    }

14.6 删除记录

@Test
    public void deleteById(){
        empRespository.deleteById("12");
    }

    @Test
    public void deleteAll(){
        empRespository.deleteAll();
    }

14.7 查询

输出结果,会发现结果已经自动封装了
/**
     * 查询所有
     */
    @Test
    public void testFindAll(){
        Iterable<Book> books = bookRespistory.findAll();
        for (Book book : books) {
            System.out.println(book);
        }
    }


    /**
     * 查询一个
     */
    @Test
    public void testFindOne(){
        Optional<Book> byId = bookRespistory.findById("21");
        System.out.println(byId.get());
    }

14.8 查询并排序

	/**
     * 排序查询
     */
    @Test
    public void testFindAllOrder(){
        Iterable<Book> books = bookRespistory.findAll(Sort.by(Sort.Order.asc("createDate")));
        books.forEach(book -> System.out.println(book) );
    }

14.9 查询分页

//分页
    @Test
    public void testPage(){
        Page<Emp> search = empRespository.search(QueryBuilders.matchAllQuery(), PageRequest.of(0, 20));
        for (Emp emp : search) {
            System.out.println(emp);
        }
    }

14.10 ElasticsearchRepository自定义查询

Keyword	Sample	Elasticsearch Query String
`And`	`findByNameAndPrice`	`{"bool" : {"must" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}`
`Or`	`findByNameOrPrice`	`{"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}`
`Is`	`findByName`	`{"bool" : {"must" : {"field" : {"name" : "?"}}}}`
`Not`	`findByNameNot`	`{"bool" : {"must_not" : {"field" : {"name" : "?"}}}}`
`Between`	`findByPriceBetween`	`{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}`
`LessThanEqual`	`findByPriceLessThan`	`{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}`
`GreaterThanEqual`	`findByPriceGreaterThan`	`{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}`
`Before`	`findByPriceBefore`	`{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}`
`After`	`findByPriceAfter`	`{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}`
`Like`	`findByNameLike`	`{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}`
`StartingWith`	`findByNameStartingWith`	`{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}`
`EndingWith`	`findByNameEndingWith`	`{"bool" : {"must" : {"field" : {"name" : {"query" : "*?","analyze_wildcard" : true}}}}}`
`Contains/Containing`	`findByNameContaining`	`{"bool" : {"must" : {"field" : {"name" : {"query" : "?","analyze_wildcard" : true}}}}}`
`In`	`findByNameIn` `(Collection<String>names)`	`{"bool" : {"must" : {"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}}`
`NotIn`	`findByNameNotIn` `(Collection<String>names)`	`{"bool" : {"must_not" : {"bool" : {"should" : {"field" : {"name" : "?"}}}}}}`
`Near`	`findByStoreNear`	`Not Supported Yet !`
`True`	`findByAvailableTrue`	`{"bool" : {"must" : {"field" : {"available" : true}}}}`
`False`	`findByAvailableFalse`	`{"bool" : {"must" : {"field" : {"available" : false}}}}`
`OrderBy`	`findByAvailable` `TrueOrderByNameDesc`	`{"sort" : [{ "name" : {"order" : "desc"} }],"bool" : {"must" : {"field" : {"available" : true}}}}`

当我们自定义的时候,我们只需要符合表格中的方法,ElasticsearchRepository就会帮我们自动封装,比如表格第一行,根据价格和姓名查询,我们在自定义的之后,方法名只要要符合 fingBy + 属性名 + And + 属性名即可,其他的同理

//自定义EmpRepository
public interface EmpRepository extends ElasticsearchRepository<Emp,String> {

    //根据姓名查询
    List<Emp> findByName(String  name);

    //根据年龄查询
    List<Emp> findByAge(Integer age);

    //根据姓名和地址
    List<Emp> findByNameAndAddressAndAge(String name,String address,Integer age);

    //根据姓名或年龄查询
    List<Emp> findByNameOrAge(String name,Integer age);

    //查询年龄大于等于 8
    List<Emp> findByAgeGreaterThanEqual(Integer value);
    
}

//基础查询 根据姓名  姓名和年龄  地址 等
    @Test
    public void testFindByName(){
        List<Emp> emps = empRepository.findByName("张君宝");
        List<Emp> emps1 = empRepository.findByAge(23);
        List<Emp> emps2 = empRepository.findByNameAndAddressAndAge("张君宝", "武当山",23);
        List<Emp> emps3 = empRepository.findByNameOrAge("张君宝", 2);
        List<Emp> emps4 = empRepository.findByAgeGreaterThanEqual(23);
        emps4.forEach(emp-> System.out.println(emp));
    }

14.10 实现复杂查询高亮查询

//复杂查询RestHighLevelClient  高亮
    @Test
    public void testSearchQuery() throws Exception {
        List<Emp> emps = new ArrayList<Emp>();
        //创建搜索请求
        SearchRequest searchRequest = new SearchRequest("ems");

        //创建搜索对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.query(QueryBuilders.termQuery("content","武侠"))//设置条件
                .sort("age", SortOrder.DESC)//排序
                .from(0) //起始条数(当前页-1)*size的值
                .size(20)//每页展示条数
                .highlighter(new HighlightBuilder().field("*").requireFieldMatch(false).preTags("<span style='color:red'>").postTags("</span>"));//设置高亮

        searchRequest.types("emp").source(searchSourceBuilder);

        //执行搜索
        SearchResponse searchResponse = restHighLevelClient.search(searchRequest, RequestOptions.DEFAULT);

        SearchHit[] hits = searchResponse.getHits().getHits();
        for (SearchHit hit : hits) {
            //原始文档
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            Emp emp =  new Emp();
            emp.setId(hit.getId());
            emp.setAge(Integer.parseInt(sourceAsMap.get("age").toString()));
            emp.setBir(new SimpleDateFormat("yyyy-MM-dd").parse(sourceAsMap.get("bir").toString()));
            emp.setContent(sourceAsMap.get("content").toString());
            emp.setName(sourceAsMap.get("name").toString());
            emp.setAddress(sourceAsMap.get("address").toString());

            //高亮字段
            Map<String, HighlightField> highlightFields = hit.getHighlightFields();
            if(highlightFields.containsKey("content")){
                emp.setContent(highlightFields.get("content").fragments()[0].toString());
            }
            if(highlightFields.containsKey("name")){
                emp.setName(highlightFields.get("name").fragments()[0].toString());
            }
            if(highlightFields.containsKey("address")){
                emp.setAddress(highlightFields.get("address").fragments()[0].toString());
            }

            //放入集合
            emps.add(emp);
        }


        emps.forEach(emp-> System.out.println(emp));
    }

15.ES中的集群

15.1 相关概念

集群(cluster)

1.单节点压力问题并发压力物理资源上限压力

2.数据冗余备份能力

一个集群就是由一个或多个节点组织在一起，它们共同持有你整个的数据，并一起提供索引和搜索功能。一个集群由一个唯一的名字标识，这个名字默认就是elasticsearch。这个名字是重要的，因为一个节点只能通过指定某个集群的名字，来加入这个集群。在产品环境中显式地设定这个名字是一个好习惯，但是使用默认值来进行测试/开发也是不错的。

节点(node)

一个节点是你集群中的一个服务器，作为集群的一部分，它存储你的数据，参与集群的索引和搜索功能。和集群类似，一个节点也是由一个名字来标识的，默认情况下，这个名字是一个随机的漫威漫画角色的名字，这个名字会在启动的时候赋予节点。这个名字对于管理工作来说挺重要的，因为在这个管理过程中，你会去确定网络中的哪些服务器对应于Elasticsearch集群中的哪些节点。

一个节点可以通过配置集群名称的方式来加入一个指定的集群。默认情况下，每个节点都会被安排加入到一个叫做“elasticsearch”的集群中，这意味着，如果你在你的网络中启动了若干个节点，并假定它们能够相互发现彼此，它们将会自动地形成并加入到一个叫做“elasticsearch”的集群中。

在一个集群里，只要你想，可以拥有任意多个节点。而且，如果当前你的网络中没有运行任何Elasticsearch节点，这时启动一个节点，会默认创建并加入一个叫做“elasticsearch”的集群。

分片和复制(shards & replicas)

一个索引可以存储超出单个结点硬件限制的大量数据。比如，一个具有10亿文档的索引占据1TB的磁盘空间，而任一节点都没有这样大的磁盘空间;或者单个节点处理搜索请求，响应太慢。为了解决这个问题，Elasticsearch提供了将索引划分成多份的能力，这些份就叫做分片。当你创建一个索引的时候，你可以指定你想要的分片的数量。每个分片本身也是一个功能完善并且独立的“索引”，这个“索引”可以被放置到集群中的任何节点上。分片之所以重要，主要有两方面的原因:

允许你水平分割/扩展你的内容容量允许你在分片(潜在地，位于多个节点上)之上进行分布式的、并行的操作，进而提高性能/吞吐量至于一个分片怎样分布，它的文档怎样聚合回搜索请求，是完全由Elasticsearch管理的，对于作为用户的你来说，这些都是透明的。

在一个网络/云的环境里，失败随时都可能发生，在某个分片/节点不知怎么的就处于离线状态，或者由于任何原因消失了。这种情况下，有一个故障转移机制是非常有用并且是强烈推荐的。为此目的，Elasticsearch允许你创建分片的一份或多份拷贝，这些拷贝叫做复制分片，或者直接叫复制。复制之所以重要，主要有两方面的原因:

在分片/节点失败的情况下，提供了高可用性。因为这个原因，注意到复制分片从不与原/主要 (original/primary)分片置于同一节点上是非常重要的。扩展你的搜索量/吞吐量，因为搜索可以在所有的复制上并行运行

总之，每个索引可以被分成多个分片。一个索引也可以被复制0次(意思是没有复制)或多次。一旦复制了，每个索引就有了主分片(作为复制源的原来的分片)和复制分片(主分片的拷贝)之别。分片和复制的数量可以在索引创建的时候指定。在索引创建之后，你可以在任何时候动态地改变复制数量，但是不能改变分片的数量。

默认情况下，Elasticsearch中的每个索引被分片5个主分片和1个复制，这意味着，如果你的集群中至少有两个节点，你的索引将会有5个主分片和另外5个复制分片(1个完全拷贝)，这样的话每个索引总共就有10个分片。一个索引的多个分片可以存放在集群中的一台主机上，也可以存放在多台主机上，这取决于你的集群机器数量。主分片和复制分片的具体位置是由ES内在的策略所决定的。

集群架构图

15.2 快速搭建集群

1. 将原有ES安装包复制三份
	cp -r elasticsearch-6.2.4/ master/
	cp -r elasticsearch-6.2.4/ slave1/
	cp -r elasticsearch-6.2.4/ slave2/
	
2. 删除复制目录中data目录 
	#注意:由于复制目录之前使用过因此需要在创建集群时将原来数据删除
	rm -rf master/data
	rm -rf slave1/data
	rm -rf slave2/data
	
3. 编辑没有文件夹中config目录中jvm.options文件跳转启动内存(因为我们一台机器上模拟的三个节点,所以我们需要把es的占用内存调小,或者把虚拟机的内存调大)
	vim master/config/jvm.options  
	vim slave1/config/jvm.options
	vim slave2/config/jvm.options
	#分别加入: -Xms512m -Xmx512m
	
4. 分别修改三个文件夹中config目录中elasticsearch.yml文件
	vim master/config/elasticsearch.yml
	vim salve1/config/elasticsearch.yml
	vim slave2/config/elasticsearch.yml
	#分别修改如下配置:
		cluster.name: my-es                       #集群名称(集群名称必须一致)
		node.name: es-03                          #节点名称(节点名称不能一致)
		network.host: 0.0.0.0                     #监听地址(必须开启远程权限,并关闭防火墙)
		http.port: 9200                           #监听端口(在一台机器时服务端口不能一致)
		discovery.zen.ping.unicast.hosts: ["172.30.2.175:9301", "172.30.2.201:9302"] #另外两个节点的ip,TCP端口
		gateway.recover_after_nodes: 3            #集群可做master的最小节点数
		transport.tcp.port: 9300				  				#集群TCP端口,默认没有,需要自己写(在一台机器搭建必须修改)  9301 9302 9303
5.	启动多个es
	./master/bin/elasticsearch
	./slave1/bin/elasticsearch
	./slave2/bin/elasticsearch
	
6. 查看节点状态

7. 查看集群健康状态(查看任意节点都一样,若需要使用kabana操作,修改kabana配置文件即可,)
	http://10.102.115.3:9200/_cat/health?v

8.若往集群中添加一个索引,再去访问http://10.102.115.3:9200/_cat/health?v 就可以看到es集群中的分片信息

15.3 安装head插件(查看es集群详细状态的可视化工具)

在root下安装

1. 访问github网站
	搜索: elasticsearch-head 插件
	
2. 安装git
	yum install git
	
3. 将elasticsearch-head下载到本地
	git clone git://github.com/mobz/elasticsearch-head.git

4. 安装nodejs
	#注意: 没有wget的请先安装yum install -y wget
	wget http://cdn.npm.taobao.org/dist/node/latest-v8.x/node-v8.1.2-linux-x64.tar.xz

5. 解压缩nodejs
	xz -d node-v10.15.3-linux-arm64.tar.xz
	tar -xvf node-v10.15.3-linux-arm64.tar

6. 配置环境变量
	mv node-v10.15.3-linux-arm64 nodejs
	mv nodejs /usr/nodejs
	vim /etc/profile
		export NODE_HOME=/usr/nodejs
		export PATH=$PATH:$JAVA_HOME/bin:$NODE_HOME/bin
	source /etc/profile
7.	进入elasticsearch-head的目录
	npm config set registry https://registry.npm.taobao.org
	npm install
	npm run start

8.  编写elastsearch.yml配置文件开启head插件的访问
	http.cors.enabled: true
	http.cors.allow-origin: "*"

9.  启动访问head插件 默认端口9100
	http://ip:9100  查看集群状态

当我们使用java操作集群的时候,这里填写所有集群的编号即可

posted @ 2020-12-27 15:11 让你上瘾的三哥阅读(479) 评论(0) 收藏举报

刷新页面返回顶部

让你上瘾的三哥