一、 初識ES

1、 認識與安裝

官網：https://www.elastic.co/cn/elasticsearch
Elasticsearch是由elastic公司開發的一套搜索引擎技術，它是elastic技術棧中的一部分。完整的技術棧包括：

• Elasticsearch：用于數據存儲、計算和搜索
• Logstash/Beats：用于數據收集
• Kibana：用于數據可視化

Kibana是elastic公司提供的用于操作Elasticsearch的可視化控制臺。它的功能非常強大，包括：

• 對Elasticsearch數據的搜索、展示
• Elasticsearch數據的統計、聚合，并形成圖形化報表、圖形
• 對Elasticsearch的集群狀態監控
• 它還提供了一個開發控制臺（DevTools），在其中對Elasticsearch的Restful的API接口提供了語法提示

安裝es

// 安裝命令
docker run -d \--name es \-e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \-e "discovery.type=single-node" \-v es-data:/usr/share/elasticsearch/data \-v es-plugins:/usr/share/elasticsearch/plugins \--privileged \--network hm-net \-p 9200:9200 \-p 9300:9300 \elasticsearch:7.12.1

端口 9200：
這是用于 HTTP 協議的端口，客戶端通過這個端口發送 REST API 請求來與 Elasticsearch 交互，比如索引數據、查詢數據、管理集群等。通常你用瀏覽器或 REST 客戶端訪問的都是這個端口。

端口 9300：
這是用于 集群內部節點通信和 Java Transport 協議的端口。Elasticsearch 集群中的節點通過該端口相互通訊，比如數據同步、節點發現和分片分配等。除非你搭建多節點集群，否則普通用戶一般不會直接訪問這個端口。

安裝 kibana

docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=hm-net \
-p 5601:5601  \
kibana:7.12.1

安裝完成后，直接訪問5601端口，即可看到控制臺頁面：

選擇Explore on my own之后，進入主頁面：

然后選中Dev tools，進入開發工具頁面：

2、 倒排索引

elasticsearch之所以有如此高性能的搜索表現，正是得益于底層的倒排索引技術。那么什么是倒排索引呢？
倒排索引的概念是基于MySQL這樣的正向索引而言的。

2.1 正向索引

例如有一張名為tb_goods的表：

其中的id字段已經創建了索引，由于索引底層采用了B+樹結構，因此我們根據id搜索的速度會非常快。但是其他字段例如title，只在葉子節點上存在。
因此要根據title搜索的時候只能遍歷樹中的每一個葉子節點，判斷title數據是否符合要求。
比如用戶的SQL語句為：
select * from tb_goods where title like ‘%手機%’;

說明：

• 1）檢查到搜索條件為like ‘%手機%’，需要找到title中包含手機的數據
• 2）逐條遍歷每行數據（每個葉子節點），比如第1次拿到id為1的數據
• 3）判斷數據中的title字段值是否符合條件
• 4）如果符合則放入結果集，不符合則丟棄
• 5）回到步驟1

綜上，根據id精確匹配時，可以走索引，查詢效率較高。而當搜索條件為模糊匹配時，由于索引無法生效，導致從索引查詢退化為全表掃描，效率很差。
因此，正向索引適合于根據索引字段的精確搜索，不適合基于部分詞條的模糊匹配。
而倒排索引恰好解決的就是根據部分詞條模糊匹配的問題。

2.2 倒排索引

倒排索引中有兩個非常重要的概念：

• 文檔（Document）：用來搜索的數據，其中的每一條數據就是一個文檔。例如一個網頁、一個商品信息
• 詞條（Term）：對文檔數據或用戶搜索數據，利用某種算法分詞，得到的具備含義的詞語就是詞條。

創建倒排索引是對正向索引的一種特殊處理和應用，流程如下：

• 將每一個文檔的數據利用分詞算法根據語義拆分，得到一個個詞條
• 創建表，每行數據包括詞條、詞條所在文檔id、位置等信息
• 因為詞條唯一性，可以給詞條創建正向索引
  此時形成的這張以詞條為索引的的表，就是倒排索引
  

倒排索引搜索流程：

流程描述：
1）用戶輸入條件"華為手機"進行搜索。
2）對用戶輸入條件分詞，得到詞條：華為、手機。
3）拿著詞條在倒排索引中查找（由于詞條有索引，查詢效率很高），即可得到包含詞條的文檔id：1、2、3。
4）拿著文檔id到正向索引中查找具體文檔即可（由于id也有索引，查詢效率也很高）。

區別：
那么為什么一個叫做正向索引，一個叫做倒排索引呢？

• 正向索引是最傳統的，根據id索引的方式。但根據詞條查詢時，必須先逐條獲取每個文檔，然后判斷文檔中是否包含所需要的詞條，是根據文檔找詞條的過程。
• 倒排索引則相反，是先找到用戶要搜索的詞條，根據詞條得到保護詞條的文檔的id，然后根據id獲取文檔。是根據詞條找文檔的過程。

正向索引：

• 優點：
  • 可以給多個字段創建索引
  • 根據索引搜索速度很快
• 缺點
  • 根據非索引字段，或者索引字段中的部分詞條查找時，只能全表掃描。

倒排索引：

• 優點：
  • 根據詞條搜索、模糊搜索速度很快
• 缺點
  • 只能給詞條創建索引，而不是字段
  • 無法根據字段做排序

3、 基本概念

3.1 文檔和字段

elasticsearch是面向**文檔（Document）**存儲的，可以是數據庫中的一條商品數據，一個訂單信息。文檔數據會被序列化為json格式后存儲在elasticsearch中：

因此，原本數據庫中的一行數據就是ES中的一個JSON文檔；而數據庫中每行數據都包含很多列，這些列就轉換為JSON文檔中的字段（Field）。

3.2 索引和倒排

隨著業務發展，需要在es中存儲的文檔也會越來越多，比如有商品的文檔、用戶的文檔、訂單文檔等等：
所有文檔都散亂存放顯然非常混亂，也不方便管理。
因此，我們要將類型相同的文檔集中在一起管理，稱為索引（Index）。例如：

• 所有用戶文檔，就可以組織在一起，稱為用戶的索引；
• 所有商品的文檔，可以組織在一起，稱為商品的索引；
• 所有訂單的文檔，可以組織在一起，稱為訂單的索引；
  因此 索引相當于數據庫中的表

數據庫的表會有約束信息，用來定義表的結構、字段的名稱、類型等信息。因此，索引庫中就有映射（mapping），是索引中文檔的字段約束信息，類似表的結構約束。

ES 和 Mysql 對比：

• Mysql：擅長事務類型操作，可以確保數據的安全和一致性
• Elasticsearch：擅長海量數據的搜索、分析、計算
• 對安全性要求較高的寫操作，使用mysql實現
• 對查詢性能要求較高的搜索需求，使用elasticsearch實現
• 兩者再基于某種方式，實現數據的同步，保證一致性
  

4 、 IK分詞器

Elasticsearch的關鍵就是倒排索引，而倒排索引依賴于對文檔內容的分詞，而分詞則需要高效、精準的分詞算法，IK分詞器就是這樣一個中文分詞算法。
安裝

docker exec -it es ./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.12.1/elasticsearch-analysis-ik-7.12.1.zip// 重啟
docker restart es

IK分詞器包含兩種模式：

• ik_smart：智能語義切分
• ik_max_word:最細粒度切分

POST /_analyze
{"analyzer": "standard",  // 這是es官方分詞器"text": "學習java太棒了"
}

結果是

{"tokens" : [{"token" : "學","start_offset" : 5,"end_offset" : 6,"type" : "<IDEOGRAPHIC>","position" : 5},{"token" : "習","start_offset" : 6,"end_offset" : 7,"type" : "<IDEOGRAPHIC>","position" : 6},{"token" : "java","start_offset" : 7,"end_offset" : 11,"type" : "<ALPHANUM>","position" : 7},{"token" : "太","start_offset" : 11,"end_offset" : 12,"type" : "<IDEOGRAPHIC>","position" : 8},{"token" : "棒","start_offset" : 12,"end_offset" : 13,"type" : "<IDEOGRAPHIC>","position" : 9},{"token" : "了","start_offset" : 13,"end_offset" : 14,"type" : "<IDEOGRAPHIC>","position" : 10}]
}

使用IK分詞器

POST /_analyze
{"analyzer": "ik_smart","text": "學習java太棒了"
}

結果

{"tokens" : [{"token" : "學習","start_offset" : 5,"end_offset" : 7,"type" : "CN_WORD","position" : 2},{"token" : "java","start_offset" : 7,"end_offset" : 11,"type" : "ENGLISH","position" : 3},{"token" : "太棒了","start_offset" : 11,"end_offset" : 14,"type" : "CN_WORD","position" : 4}]
}

拓展詞典
要想正確分詞，IK分詞器的詞庫也需要不斷的更新，IK分詞器提供了擴展詞匯的功能。
1）打開IK分詞器config目錄：

注意，如果采用在線安裝的通過，默認是沒有config目錄的
2）在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.dic</entry>
</properties>

3）在IK分詞器的config目錄新建一個 ext.dic，可以參考config目錄下復制一個配置文件進行修改
笑屎了
4） 重啟es

二、 操作

1、 mapping 映射屬性

Mapping是對索引庫中文檔的約束，常見的Mapping屬性包括：

• type：字段數據類型，常見的簡單類型有：
  • 字符串：text（可分詞的文本）、keyword（精確值，例如：品牌、國家、ip地址）
  • 數值：long、integer、short、byte、double、float、
  • 布爾：boolean
  • 日期：date
  • 對象：object
• index：是否創建索引，默認為true
• analyzer：使用哪種分詞器
• properties：該字段的子字段

例如：

2、 索引庫增刪改查

由于Elasticsearch采用的是Restful風格的API，因此其請求方式和路徑相對都比較規范，而且請求參數也都采用JSON風格。
我們直接基于Kibana的DevTools來編寫請求做測試，由于有語法提示，會非常方便。

1. 創建索引庫
   基本語法：

• 請求方式：/PUT
• 請求路徑：/索引庫名
• 請求參數：mapping映射

PUT /索引庫名稱
{"mappings": {"properties": {"字段名":{"type": "text","analyzer": "ik_smart"},"字段名2":{"type": "keyword","index": "false"},"字段名3":{"properties": {"子字段": {"type": "keyword"}}},// ...略}}
}

2. 查詢索引庫
   基本語法：

• • 請求方式：GET
• • 請求路徑：/索引庫名
• • 請求參數：無

GET /索引庫名

3. 修改索引庫
   倒排索引結構雖然不復雜，但是一旦數據結構改變（比如改變了分詞器），就需要重新創建倒排索引，這簡直是災難。因此索引庫一旦創建，無法修改mapping。

雖然無法修改mapping中已有的字段，但是卻允許添加新的字段到mapping中，因為不會對倒排索引產生影響。因此修改索引庫能做的就是向索引庫中添加新字段，或者更新索引庫的基礎屬性。

PUT /索引庫名/_mapping
{"properties": {"新字段名":{"type": "integer"}}
}

4. 刪除索引庫
   基本語法：

• • 請求方式：DELETE
• • 請求路徑：/索引庫名
• • 請求參數：無

總結：

• • 創建索引庫：PUT /索引庫名
• • 查詢索引庫：GET /索引庫名
• • 刪除索引庫：DELETE /索引庫名
• • 修改索引庫，添加新字段：PUT /索引庫名/_mapping

3、 文檔的增刪改查

3.1 新增文檔

POST /索引庫名/_doc/文檔id
{"字段1": "值1","字段2": "值2","字段3": {"子屬性1": "值3","子屬性2": "值4"},
}// 示例
POST /test/_doc/1
{"info": "今天是端午節","email": "111@qq.com.cn","name": {"firstName": "D","lastName": "H"}
}

3.2 查詢文檔

GET /{索引庫名稱}/_doc/{id}// 示例
GET/test1/_doc/1

3.3 刪除文檔

DELETE /{索引庫名}/_doc/id值// 示例
DELETE/test1/_doc/1

3.4 修改文檔

修改有兩種方式：

• 全量修改：直接覆蓋原來的文檔
• 局部修改：修改文檔中部分字段

全量修改
全量修改是覆蓋原來的文檔，其本質是兩步操作。1.根據指定id刪除文檔，新增一個相同id的文檔
如果id不存在，那么就相當于新增一個id的文檔

PUT /{索引庫名}/_doc/文檔id
{"字段1": "值1","字段2": "值2",// ... 略
}

局部修改
局部修改只修改指定id的文檔中的部分字段

POST /{索引庫名}/_update/文檔id
{"doc": {"字段名": "新的值",}
}

3.5 批處理

批處理采用POST請求，基本語法如下

POST _bulk
{ "index" : { "_index" : "test", "_id" : "1" } }
{ "field1" : "value1" }
{ "delete" : { "_index" : "test", "_id" : "2" } }
{ "create" : { "_index" : "test", "_id" : "3" } }
{ "field1" : "value3" }
{ "update" : {"_id" : "1", "_index" : "test"} }
{ "doc" : {"field2" : "value2"} }

其中：

• index代表新增操作
  • _index:指定索引庫名
  • _id：指定要操作的文檔id
  • {“filed1”:“value1”}：要新增的文檔內容
• delete代表刪除操作
  • _index：指定索引庫名
  • _id :指定要操作的文檔id
• update代表更新操作
  • _index：指定索引庫名
  • _id :指定要操作的文檔id
  • {“doc”:{“filed2”:“value2”} }：要更新的字段

// 批量新增
POST /_bulk
{"index": {"_index":"test1", "_id": "3"}}
{"info": "C++", "email": "111222@q.com", "name":{"firstName": "五", "lastName":"王"}}
{"index": {"_index":"heima", "_id": "4"}}
{"info": "前端", "email": "333444@qq.com", "name":{"firstName": "三", "lastName":"張"}}

// 批量刪除
POST /_bulk
{"delete":{"_index":"heima", "_id": "3"}}
{"delete":{"_index":"heima", "_id": "4"}}

三、 RestAPI

ES官方提供了各種不同語言的客戶端，用來操作ES。這些客戶端的本質就是組裝DSL語句，通過http請求發送給ES。
官方文檔地址：
https://www.elastic.co/guide/en/elasticsearch/client/index.html

// 引入es的RestHighLevelClient依賴
<dependency><groupId>org.elasticsearch.client</groupId><artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

寫一個測試類：

package com.hmall.item.es;import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;import java.io.IOException;public class IndexTest {private RestHighLevelClient client;@BeforeEachvoid setUp() {this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.1.1:9200")));}@Testvoid testConnect() {System.out.println(client);}@AfterEachvoid tearDown() throws IOException {this.client.close();}
}

3.1 索引庫操作

3.1.1 創建索引庫

1. 首先需要進行字段篩選，將需要索引的字段找出來，確定字段類型以及是否需要索引。
   

2. 創建索引映射。就是索引語句。只需要mappings 部分
   

@Test
void testCreateIndex() throws IOException {// 1.創建Request對象CreateIndexRequest request = new CreateIndexRequest("items");// 2.準備請求參數request.source("", XContentType.JSON);// 3.發送請求client.indices().create(request, RequestOptions.DEFAULT);
}

代碼分為三步：

• 1）創建Request對象。因為是創建，所以使用CreateIndexRequest
• 2）添加請求參數：其實就是Json格式的Mapping映射參數。
• 3）發送請求
• client.indices()方法的返回值是IndicesClient類型，封裝了所有與索引庫操作有關的方法。例如創建索引、刪除索引、判斷索引是否存在等

3.1.2 刪除索引庫

@Test
void testDeleteIndex() throws IOException {// 1.創建Request對象DeleteIndexRequest request = new DeleteIndexRequest("items");// 2.發送請求client.indices().delete(request, RequestOptions.DEFAULT);
}

3.1.3 查找索引庫

@Test
void testExistsIndex() throws IOException {// 1.創建Request對象GetIndexRequest request = new GetIndexRequest("items");// 2.發送請求boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);// 3.輸出System.err.println(exists ? "索引庫已經存在！" : "索引庫不存在！");
}

3.2 文檔操作

package com.hmall.item.es;import com.hmall.item.service.IItemService;
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;import java.io.IOException;@SpringBootTest(properties = "spring.profiles.active=local")
public class DocumentTest {private RestHighLevelClient client;@Autowiredprivate IItemService itemService;@BeforeEachvoid setUp() {this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.1.1:9200")));}@AfterEachvoid tearDown() throws IOException {this.client.close();}
}

3.2.1 新增文檔

API語法為

POST /{索引庫名}/_doc/1
{"name": "Jack","age": 21
}

@Test
void testAddDocument() throws IOException {// 1.根據id查詢商品數據Item item = itemService.getById(100002644680L);// 2.轉換為文檔類型ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);// 3.將ItemDTO轉jsonString doc = JSONUtil.toJsonStr(itemDoc);// 1.準備Request對象IndexRequest request = new IndexRequest("items").id(itemDoc.getId());// 2.準備Json文檔request.source(doc, XContentType.JSON);// 3.發送請求client.index(request, RequestOptions.DEFAULT);
}

3.2.2 查詢文檔

GET /{索引庫名}/_doc/{id}

可以看到，響應結果是一個JSON，其中文檔放在一個_source屬性中，因此解析就是拿到_source，反序列化為Java對象即可。

@Test
void testGetDocumentById() throws IOException {// 1.準備Request對象GetRequest request = new GetRequest("items").id("100002644680");// 2.發送請求GetResponse response = client.get(request, RequestOptions.DEFAULT);// 3.獲取響應結果中的sourceString json = response.getSourceAsString();ItemDoc itemDoc = JSONUtil.toBean(json, ItemDoc.class);System.out.println("itemDoc= " + ItemDoc);
}

3.2.3 刪除文檔

DELETE /hotel/_doc/{id}

@Test
void testDeleteDocument() throws IOException {// 1.準備Request，兩個參數，第一個是索引庫名，第二個是文檔idDeleteRequest request = new DeleteRequest("item", "100002644680");// 2.發送請求client.delete(request, RequestOptions.DEFAULT);
}

3.2.4 修改文檔

修改我們講過兩種方式：

• 全量修改：本質是先根據id刪除，再新增
• 局部修改：修改文檔中的指定字段

POST /{索引庫名}/_update/{id}
{
“doc”: {
“字段名”: “字段值”,
“字段名”: “字段值”
}
}

在RestClient的API中，全量修改與新增的API完全一致，判斷依據是ID：

• 如果新增時，ID已經存在，則修改
• 如果新增時，ID不存在，則新增

@Test
void testUpdateDocument() throws IOException {// 1.準備RequestUpdateRequest request = new UpdateRequest("items", "100002644680");// 2.準備請求參數request.doc("price", 58800,"commentCount", 1);// 3.發送請求client.update(request, RequestOptions.DEFAULT);
}

3.3 批量導入文檔

我們如果要將這些數據導入索引庫，肯定不能逐條導入，而是采用批處理方案。常見的方案有：

• 利用Logstash批量導入
  • 需要安裝Logstash
  • 對數據的再加工能力較弱
  • 無需編碼
• 利用JavaAPI批量導入
  • 需要編碼
  • 更加靈活

批處理與前面講的文檔的CRUD步驟基本一致：創建request，使用的是BulkRequest，準備參數，發送請求
BulkRequest本身其實并沒有請求參數，其本質就是將多個普通的CRUD請求組合在一起發送。例如：

• 批量新增文檔，就是給每個文檔創建一個IndexRequest請求，然后封裝到BulkRequest中，一起發出。
• 批量刪除，就是創建N個DeleteRequest請求，然后封裝到BulkRequest，一起發出
• 因此BulkRequest中提供了add方法，用以添加其它CRUD的請求：
  

@Test
void testBulk() throws IOException {// 1.創建RequestBulkRequest request = new BulkRequest();// 2.準備請求參數request.add(new IndexRequest("items").id("1").source("json doc1", XContentType.JSON));request.add(new IndexRequest("items").id("2").source("json doc2", XContentType.JSON));// 3.發送請求client.bulk(request, RequestOptions.DEFAULT);
}

@Test
void testLoadItemDocs() throws IOException {// 分頁查詢商品數據int pageNo = 1;int size = 1000;while (true) {Page<Item> page = itemService.lambdaQuery().eq(Item::getStatus, 1).page(new Page<Item>(pageNo, size));// 非空校驗List<Item> items = page.getRecords();if (CollUtils.isEmpty(items)) {return;}log.info("加載第{}頁數據，共{}條", pageNo, items.size());// 1.創建RequestBulkRequest request = new BulkRequest("items");// 2.準備參數，添加多個新增的Requestfor (Item item : items) {// 2.1.轉換為文檔類型ItemDTOItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);// 2.2.創建新增文檔的Request對象request.add(new IndexRequest().id(itemDoc.getId()).source(JSONUtil.toJsonStr(itemDoc), XContentType.JSON));}// 3.發送請求client.bulk(request, RequestOptions.DEFAULT);// 翻頁pageNo++;}
}