代码拉取完成，页面将自动刷新
ElasticSearch
我们要讲解什么？
SQL：like %狂神说% ,如果是大数据，就十分慢！需要建立索引来加快速度！
ElasticSearch：搜索！（百度、github、淘宝电商！）
1、聊一个人
2、货比三家
3、安装
4、生态圈！
5、分词器！ik 分词器
6、RestFul 操作 ES
7、CRUD
8、SpringBoot 集成 ElasticSearch（从原理分析！）
9、爬虫爬取数据！
10、实战，模拟全文搜索！
以后只要需要用到搜索，就可以使用 ES！（大数据量的情况下使用！）
概述
历史：
谁在使用：
回到主题
Lucene 是一套信息检索工具包！jar 包！ 不包含 搜索引擎系统！
包含的：索引结构！读写索引的工具！排序，搜索规则......工具类！
Lucene 和 ElasticSearch 关系：
ElasticSearch 是基于 Lucene 做了一些封装和增强（我们上手是十分简单！）
ElasticSearch 简介：
Elasticsearch 是一个实时分布式搜索和分析引擎。它让你以前所未有的速度处理大数据成为可能。
它用于全文搜索、结构化搜索、分析以及将这三者混合使用：
Solr简介：
Lucene简介：
ElasticSearch和Solr比较：
ElastucSearch VS Solr 总结：
es基本是开箱即用（解压就可以使用！）非常简单。Solr安装略微复杂一丢丢！
Solr利用Zookeeper进行分布式管理，而ElasticSearch自身带有分布式协调管理功能。
Solr支持多种数据格式，比如JSON、XML、CSV，而ElasticSearch仅支持JSON文件格式。
Solr官网提供的功能更多，而ElasticSearch本身更注重于核心功能，高级等级功能多有第三方插件提供，例如图形化界面需要kibana友好支撑！
Solr查询快，但更新索引时慢（即插入删除慢），用于电商等查询多的应用
ES建立索引快（即查询慢），即实时性查询快，用于Facebook、新浪等搜索。
Solr比较成熟，有一个更大，更成熟的用户、开发和贡献者社区，而ElasticSearch相对开发维护者较少，更新太快，学习使用成本较高！
声明：JDK1.8，最低要求！ElasticSearch 客户端，界面工具！
Java开发，ElasticSearch 的版本和我们之后对应的Java的核心jar 包！版本对应！JDK环境正常
Windows下安装ElasticSearch：
1、解压即可使用：
bin：启动文件
config：配置文件
log4j2.properties：日志配置文件
jvm.options：Java虚拟机相关配置
elasticsearch.yml：elasticsearch配置文件!默认9200端口!跨域！
lib：相关jer包
los：日志文件
modules：功能模块
plugins：插件 ik分词器
1、启动elasticsearch：双击 bin/elasticsearch.bat 文件即可
3、安装可视化插件 - elasticsearch-head-master：
解压即可：
进入该目录打开CMD窗口安装note.js文件：cnpm install
启动elasticsearch-head-master：npm run start
会发现因为跨域问题无法访问，需要在elasticsearch.yml中添加如下配置：
# 跨域设置
http.cors.enabled: true
http.cors.allow-origin: "*"
重启ES服务，再次连接：
初学，就把 es 当作一个数据库！（可以建立索引（库））文档
这个head我们就把他当作数据展示工具！我们后面所有的查询都在 kibana
ELK 是 Elastic Search、Logstash、Kibana 三大开源框架首字母大写简称。市面上也被称为 Elastic stack。其中 ElasticSearch 是一个基于 Lucene、分布式、通过 RestFul 方式进行交互的近实时搜索平台框架。像类似百度、谷歌这种大数据全文搜索引擎的场景都可以使用 ElasticSearch 作为底层支持框架，可见 ElasticSearch 提供的搜索能力确实强大，市面上很多时候我们简称 ElasticSearch为es。Logstash 是Elk的中央数据流引擎，用于从不同的目标（文件/数据存储/MQ）收集的不同格式数据。经过过滤后支持输出到不同目的地（文件/MQ/redis/elasticSearch）。Kibana 可以将 elasticsearch 的数据通过友好的页面展示出来，提供实时分析的功能。
市面上很多开发只要提到 ELK 能够一致说出它是一个日志分析架构技术栈总称，但实际上ELK不仅仅适用于日志分析，他还可以支持其他任何数据分析和收集的场景，日志分析和收集只是更具有代表性，并非唯一性。
Kibana概述：
Kibana是一个针对Elasticsearch的开源分析及可视化平台，用来搜索、查看交互存储在Elasticsearch索引中的数据。使用Kibana，可以通过各种图表进行高级数据分析及展示。Kibana让海量数据更容易理解。它操作简单，基于浏览器的用户界面可以快速创建仪表板（dashboard）实时显示Elasticsearch查询动态。设置Kibana非常简单。无需编码或者额外的基础架构，几分钟内就可以完成Kibana安装并启动Elasticsearch索引监测。
解压即可：
双击 bin/kibana.bat 启动Kibana
开发工具（Postman、curl、head、谷歌浏览器插件测试）：
在配置文件（kibana.yml）中将界面语言设置成中文：i18n.locale: "zh-CN"，重启Kibana即可生效：
==集群、节点、索引、类型、文档、分片、映射是什么？==
elasticsearch是面向文档，数据库 和 elasticsearch 客观的对比： 一切都是 JSON
| Relational****DB | ElasticSearch |
|---|---|
| 数据库(database) | 索引(index) |
| 表(tables) | types |
| 行(rows) | documents |
| 字段(columns) | fields |
ES（集群）中可以包含多个索引（数据库），每个索引中可以包含多个类型（表），每个类型下又包含多个文档（行），每个文档中又包含多个字段（列）。
物理设计：
ES在后台把每个索引划分成多个分片，每份分片可以在集群中的不同服务器间迁移，一个人就是一个集群！默认的集群名是elasticsearch。
逻辑设计：
一个索引类型中，包含多个文档，比如说文档1，文档2。 当我们索引一篇文档时，可以通过这样的一各顺序找到它: 索引 ▷ 类型 ▷ 文档ID ，通过这个组合我们就能索引到某个具体的文档。 注意:ID不必是整数，实际上它是个字 符串。
文档：
就是我们的一条条数据
user
1 zhangsan 18
2 kuangshen 3
之前说elasticsearch是面向文档的，那么就意味着索引和搜索数据的最小单位是文档，elasticsearch中，文档有几个 重要属性 :
自我包含，一篇文档同时包含字段和对应的值，也就是同时包含 key:value！
可以是层次型的，一个文档中包含自文档，复杂的逻辑实体就是这么来的！ {就是一个json对象！ fastjson进行自动转换！}
灵活的结构，文档不依赖预先定义的模式，我们知道关系型数据库中，要提前定义字段才能使用，在elasticsearch中，对于字段是非常灵活的，有时候，我们可以忽略该字段，或者动态的添加一个新的字段。
尽管我们可以随意的新增或者忽略某个字段，但是，每个字段的类型非常重要，比如一个年龄字段类型，可以是字符 串也可以是整形。因为elasticsearch会保存字段和类型之间的映射及其他的设置。这种映射具体到每个映射的每种类型，这也是为什么在elasticsearch中，类型有时候也称为映射类型。
类型：
类型是文档的逻辑容器，就像关系型数据库一样，表格是行的容器。 类型中对于字段的定义称为映射， 比如 name 映射为字符串类型。 我们说文档是无模式的，它们不需要拥有映射中所定义的所有字段，比如新增一个字段，那么elasticsearch是怎么做的呢?elasticsearch会自动的将新字段加入映射，但是这个字段的不确定它是什么类型，elasticsearch就开始猜，如果这个值是18，那么elasticsearch会认为它是整形。 但是elasticsearch也可能猜不对， 所以最安全的方式就是提前定义好所需要的映射，这点跟关 系型数据库殊途同归了，先定义好字段，然后再使用，别整什么幺蛾子。
索引：就是数据库
索引是映射类型的容器，elasticsearch中的索引是一个非常大的文档集合。索引存储了映射类型的字段和其他设置。 然后它们被存储到了各个分片上了。 我们来研究下分片是如何工作的。
一个集群至少有一个节点，而一个节点就是一个elasricsearch进程，节点可以有多个索引默认的，如果你创建索引，那么索引将会有个5个分片 ( primary shard ,又称主分片 ) 构成的，每一个主分片会有一个副本 ( replica shard ,又称复制分片 )。
上图是一个有3个节点的集群，可以看到主分片和对应的复制分片都不会在同一个节点内，这样有利于某个节点挂掉 了，数据也不至于丢失。 实际上，一个分片是一个Lucene索引，一个包含==倒排索引==的文件目录，倒排索引的结构使 得elasticsearch在不扫描全部文档的情况下，就能告诉你哪些文档包含特定的关键字。 不过，等等，倒排索引是什么鬼?
倒排索引：
如果要搜索含有 python 标签的文章，那相对于查找所有原始数据而言，查找倒排索引后的数据将会快的多。只需要查看标签这一栏，然后获取相关的文章ID即可。完全过滤掉无关的所有数据，提高效率！
elasticsearch的索引和Lucene的索引对比：
在elasticsearch中， 索引 （库）这个词被频繁使用，这就是术语的使用。 在elasticsearch中，索引被分为多个分片，每份 分片是一个Lucene的索引。==所以一个elasticsearch索引是由多个Lucene索引组成的==。别问为什么，谁让elasticsearch使用Lucene作为底层呢! 如无特指，说起索引都是指elasticsearch的索引。
什么是IK分词器：
分词：即把一段中文或者别的划分成一个个的关键字，我们在搜索时候会把自己的信息进行分词，会把数据库中或者索引库中的数据进行分词，然后进行一个匹配操作，默认的中文分词是将每个字看成一个词，比如 “我爱狂神” 会被分为"我","爱","狂","神"，这显然是不符合要求的，所以我们需要安装中文分词器ik来解决这个问题。
如果要使用中文，建议使用ik分词器！
IK提供了两个分词算法：==ik_smart== 和 ==ik_max_word==，其中 ik_smart 为最少切分，ik_max_word为最细粒度划分！一会我们测试！
安装IK分词器：
下载完毕之后，放入 es 的 plugins 文件夹下即可
重启观察ES：
可以通过 elasticsearch-plugin list 命令来查看加载进来的插件：
使用IK分词器进行测试（查看不同的分词器效果）：
IK提供了两个分词算法：==ik_smart== 和 ==ik_max_word==
自定义分词：
狂神说被拆开了，我们是不希望拆开这个词的，所以可以自定义分词：
编写自己的配置文件（mao.dic [狂神说]）,并在IK配置文件中配置：
重启ES即可（可以从日志文件中看到我们的分词器已经被加载）：
查看效果： 
一种软件架构风格，而不是标准，只是提供了一组设计原则和约束条件。他主要用于客户端和服务器交互类的软件。基于这个风格设计的软件可以更简洁，更有层次，更易于实现缓存等机制。
基于Rest命令说明：
| method | url地址 | 描述 |
|---|---|---|
| PUT | localhost:9200/索引名称/类型名称/文档id | 创建文档（指定文档id） |
| POST | localhost:9200/索引名称/类型名称 | 创建文档（随机文档id） |
| POST | localhost:9200/索引名称/类型名称/文档id/_update | 修改文档 |
| DELETE | localhost:9200/索引名称/类型名称/文档id | 删除文档 |
| GET | localhost:9200/索引名称/类型名称/文档id | 查询文档通过文档id |
| POST | localhost:9200/索引名称/类型名称/_search | 查询所有数据 |
创建索引库：
PUT /索引名/~类型名~/文档ID
{
请求体
}
完成了自动增加了索引！数据也成功的添加了
ES的字段类型：
字符串类型：text [会被分词器解析]、 keyword [不会被分词器解析]
数值类型：long, integer, short, byte, double, float, half_float, scaled_float
日期类型：date
布尔值类型：boolean
二进制类型：binary
创建索引的时候指定字段类型：
获得规则：可以通过 GET 请求获取具体的信息！
查询索引：GET 索引名
如果自己的文档字段没有指定，那么 es 就会给我们默认配置字段类型！
扩展：通过命令 elasticsearch 索引情况！查看默认的配置：GET _ cat/xxx，可以获得当前 es 很多默认的信息
修改索引信息：提交还是使用PUT即可！然后覆盖，也可以用
曾经的方法：
使用POST方式进行修改
删除索引：DELETE 索引名
通过 DELETE 命令实现删除、根据请求来判断是删除索引还是删除文档记录！
添加数据：
PUT /mao/user/1
{
"name": "但愿人长久",
"age": 22,
"desc": "一顿操作猛如虎，一看工资2500",
"tags": ["技术宅","温暖","直男"]
}
PUT /mao/user/2
{
"name": "张三",
"age": 3,
"desc": "法外狂徒",
"tags": ["交友","旅游","渣男"]
}
PUT /mao/user/3
{
"name": "李四",
"age": 30,
"desc": "不知道如何形容",
"tags": ["靓女","旅游","唱歌"]
}
查询数据：
根据ID查询：GET 索引名/类型名/文档ID
GET mao/user/1
更新数据（比如更新3号用户）：
PUT /mao/user/3
{
"name": "李四233",
"age": 30,
"desc": "不知道如何形容",
"tags": ["靓女","旅游","唱歌"]
}
用POST _update更新
PUT /mao/user/1
{
"name": "但愿人长久",
"age": 22,
"desc": "一顿操作猛如虎，一看工资2500",
"tags": ["技术宅","温暖","直男"]
}
POST mao/user/1/_update
{
"doc": {
"name": "但愿人长久更新"
}
}
简单的搜索
GET mao/user/1
简单的条件查询，可以默认的映射规则产生基本的查询！
带条件的查询：GET 索引名/类型名/_search { 条件 }
复杂的查询搜索——select（排序，分页，高亮，模糊查询，精准查询！）
查询指定的字段
查询指定的字段--结果字段的过滤
GET mao/user/_search
{
"query": {
"match": {
"name": "但愿人长久"
}
},
"_source": ["name","desc"]
}
排序查询：
GET mao/user/_search
{
"query": {
"match": {
"name": "但愿人长久"
}
},
"sort": [
{
"age": {
"order": "asc"
}
}
]
}
分页查询：数据下标还是从 0 开始的，和学的所有数据结构是一样的！
GET mao/user/_search
{
"query": {
"match": {
"name": "但愿人长久"
}
},
"sort": [
{
"age": {
"order": "asc"
}
}
],
"from": 0,
"size": 1
}
布尔值查询：
==must（and），所有的条件都要符合，就相当于多条件查询 where xxx and xxx==
==should（or），所有的条件都要符合，就相当于多条件查询 where xxx orxxx==
==must_not==
过滤器查询： filter
多条件查询：
精确查找：
PUT testdb
{
"mappings": {
"properties": {
"name": {
"type": "text"
},
"desc": {
"type": "keyword"
}
}
}
}
#####################################
PUT testdb/_doc/1
{
"name": "狂神说Java name",
"desc": "狂神说Java desc"
}
PUT testdb/_doc/2
{
"name": "狂神说Java name2",
"desc": "狂神说Java desc2"
}
######################################
GET testdb/_search
{
"query": {
"term": {
"name": "狂"
}
}
}
GET testdb/_search
{
"query": {
"term": {
"desc": "狂神说Java desc"
}
}
}
可以知道term为精确搜索，意思就是说所查询的字段必须符合我们输入的条件，不会被分词解析。
但为什么上面那个搜索就可以呢，因为上面那个的 name 字段的类型是text，默认情况下text是analysis的一部分，elasticsearch 会对其进行分词解析。==因此，一般会避免 term 对 text 字段进行查询。
精确查询多个值
PUT testdb/_doc/3
{
"t1": 22,
"t2": "2021-7-8"
}
PUT testdb/_doc/4
{
"t1": 33,
"t2": "2021-7-9"
}
GET testdb/_search
{
"query": {
"bool": {
"should": [
{
"term": {
"t1": 22
}
},
{
"term": {
"t1": 33
}
}
]
}
}
}
高亮查询：
自定义高亮
找文档
1、找到原生依赖
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>7.13.3</version>
</dependency>
2、找对象
3、分析 API 的方法
配置基本的项目
==问题：一定要保证我们导入的依赖和我们的 es 版本一致==
==自定义版本依赖==
自定义RestHighLevelClient
/**
* 1、找对象
* 2、放到 spring 中待用！
* 3、如果是 SpringBoot 就先分析源码
*/
@Configuration
public class ElasticSearchConfig {
/**
* 自定义配置类的话应该要注意方法名
* <bean id="restHighLevelClient" class="RestHighLevelClient" />
* @return
*/
@Bean
public RestHighLevelClient restHighLevelClient(){
return new RestHighLevelClient(
RestClient.builder(
new HttpHost("127.0.0.1",9200,"http")
)
);
}
}
具体的 API 测试！
1、创建索引
// 测试索引的创建
@Test
void testCreateIndex() throws IOException {
// 1、创建索引的请求
CreateIndexRequest request = new CreateIndexRequest("mao_index");
// 2、客户端执行请求 IndicesClient，请求后获得响应
CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);
System.out.println(createIndexResponse);
}
2、测试索引，判断其是否存在
// 测试获取索引，只能判断其是否存在
@Test
void testExistIndex() throws IOException {
GetIndexRequest request = new GetIndexRequest("mao_index");
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
System.out.println(exists);
}
3、测试删除索引
// 测试删除索引
@Test
void testDeleteIndex() throws IOException {
DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("mao_index");
AcknowledgedResponse delete = client.indices().delete(deleteIndexRequest, RequestOptions.DEFAULT);
System.out.println(delete.isAcknowledged());
}
4、测试添加文档
// 测试添加文档
@Test
void testAddDocument() throws IOException {
// 创建对象
User user = new User("但愿人长久", 3);
// 创建请求
IndexRequest request = new IndexRequest("mao_index");
// 规则 put /mao_index/user/1
request.id("1")
.timeout("1s")
// 将我们的数据放入请求 json
.source(JSON.toJSONString(user), XContentType.JSON);
IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);
System.out.println(indexResponse.toString());
System.out.println(indexResponse.status()); // 对应我们命令返回的状态 CREATED
}
5、获取文档，判断是否存在
// 获取文档，判断是否存在
@Test
void testIsExist() throws IOException {
GetRequest getRequest = new GetRequest("mao_index","1");
// 不获取返回的 _source 的上下文了
getRequest.fetchSourceContext(new FetchSourceContext(false))
.storedFields("_none_");
boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);
System.out.println(exists);
}
6、获取文档信息
// 获取文档信息
@Test
void testGetDocument() throws IOException {
GetRequest getRequest = new GetRequest("mao_index", "1");
GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);
System.out.println(getResponse.getSourceAsString());// 获取并打印文档的内容
System.out.println(getResponse);
}
7、更新文档信息
// 更新文档信息
@Test
void testUpdateDocument() throws IOException {
UpdateRequest updateRequest = new UpdateRequest("mao_index", "1");
User user = new User("但愿人长久更新测试", 23);
updateRequest.doc(JSON.toJSONString(user),XContentType.JSON);
UpdateResponse updateResponse = client.update(updateRequest, RequestOptions.DEFAULT);
System.out.println(updateResponse.status());
}
8、删除文档记录
// 删除文档记录
@Test
void testDeleteDocument() throws IOException {
DeleteRequest deleteRequest = new DeleteRequest("mao_index", "1");
deleteRequest.timeout("1s");
DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);
System.out.println(deleteResponse.status());
}
9、特殊的，真实的项目一般都会批量查询插入数据
// 特殊的，真实的项目一般都会批量查询插入数据
@Test
void testBulkRequest() throws IOException {
// 这就是相当于一个存储 IndexRequest 对象的集合
BulkRequest bulkRequest = new BulkRequest("mao_index");
bulkRequest.timeout("10s");
List<User> userList = new ArrayList<>();
userList.add(new User("但愿人长久1",1));
userList.add(new User("但愿人长久2",1));
userList.add(new User("但愿人长久3",1));
userList.add(new User("狂神说Java1",1));
userList.add(new User("狂神说Java2",1));
userList.add(new User("狂神说Java3",1));
// 批处理请求，其实就是遍历集合将每一个元素封装在 IndexRequest 中，然后将 IndexRequest 封装在 bulkRequest 中
for (int i = 0; i < userList.size(); i++) {
bulkRequest.add(
new IndexRequest("mao_index")
.id("" + (i+1))
.source(JSON.toJSONString(userList.get(i)),XContentType.JSON)
);
}
BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);
System.out.println(bulkResponse.hasFailures());// 是否失败，返回false代表成功
}
10、查询
// 查询
/**
* searchRequest 搜索请求
* searchSourceBuilder 条件构造
* searchSourceBuilder.highlighter() 构建高亮
* TermQueryBuilder 精确查询====但是要注意这里如果用精确查询要保证查询字段不是 text字段，因为text字段会被分词解析，可以用 字段.keyword
* MatchAllQueryBuilder 查询全部
* xxx QueryBuilder 就是对应 kibana 中的命令
* @throws IOException
*/
@Test
void testSearch() throws IOException {
SearchRequest searchRequest = new SearchRequest("mao_index");
// 构建搜索条件
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
// searchSourceBuilder.highlighter()
// 查询条件，我们可以使用 QueryBuilders.termQuery() 方法
// QueryBuilders.termQuery 精确匹配
// QueryBuilders.matchAllQuery() 匹配所有
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name.keyword", "但愿人长久1");
// MatchAllQueryBuilder matchAllQueryBuilder = QueryBuilders.matchAllQuery();
searchSourceBuilder.query(termQueryBuilder);
searchSourceBuilder.timeout(new TimeValue(60, TimeUnit.SECONDS));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);
System.out.println(JSON.toJSONString(searchResponse.getHits()));
System.out.println("==========================================");
for (SearchHit hit : searchResponse.getHits().getHits()) {
System.out.println(hit.getSourceAsMap());
}
}
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。