一、安装elasticsearch
1.1 安装elaticsearch
通过下面的Docker命令即可安装单机版本的elasticsearch：
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端口： 如下结果说明安装成功
1.2 安装Kibana
通过下面的Docker命令，即可部署Kibana：
docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=hm-net \
-p 5601:5601 \
kibana:7.12.11.3 安装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
然后重启es容器：
docker restart es
方案二：离线安装
如果网速较差，也可以选择离线安装。
首先，查看之前安装的Elasticsearch容器的plugins数据卷目录：
docker volume inspect es-plugins
最后，重启es容器：
docker restart es
二、倒排索引
2.1 倒排索引的概念：
倒排索引中有两个非常重要的概念：
-
文档（
Document）：用来搜索的数据，其中的每一条数据就是一个文档。例如一个网页、一个商品信息 -
词条（
Term）：对文档数据或用户搜索数据，利用某种算法分词，得到的具备含义的词语就是词条。例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条
建倒排索引是对正向索引的一种特殊处理和应用，流程如下：
-
将每一个文档的数据利用分词算法根据语义拆分，得到一个个词条
-
创建表，每行数据包括词条、词条所在文档id、位置等信息
-
因为词条唯一性，可以给词条创建正向索引
此时形成的这张以词条为索引的表，就是倒排索引表，两者对比如下：
正向索引
| id（索引） | title | price |
|---|---|---|
| 1 | 小米手机 | 3499 |
| 2 | 华为手机 | 4999 |
| 3 | 华为小米充电器 | 49 |
| 4 | 小米手环 | 49 |
| ... | ... | ... |
倒排索引
| 词条（索引） | 文档id |
|---|---|
| 小米 | 1，3，4 |
| 手机 | 1，2 |
| 华为 | 2，3 |
| 充电器 | 3 |
| 手环 | 4 |
那么两者方式的优缺点是什么呢？
正向索引：
-
优点：
-
可以给多个字段创建索引
-
根据索引字段搜索、排序速度非常快
-
-
缺点：
-
根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描。
-
倒排索引：
-
优点：
-
根据词条搜索、模糊搜索时，速度非常快
-
-
缺点：
-
只能给词条创建索引，而不是字段
-
无法根据字段做排序
-
2.2 索引
我们要将类型相同的文档集中在一起管理，称为索引（Index）
商品索引
{ "id": 1, "title": "小米手机", "price": 3499 } { "id": 2, "title": "华为手机", "price": 4999 } { "id": 3, "title": "三星手机", "price": 3999 }用户索引
{ "id": 101, "name": "张三", "age": 21 } { "id": 102, "name": "李四", "age": 24 } "id": 103, "name": "麻子", "age": 18 }
订单索引
{ "id": 10, "userId": 101, "goodsId": 1, "totalFee": 294 } { "id": 11, "userId": 102, "goodsId": 2, "totalFee": 328 } -
所有用户文档，就可以组织在一起，称为用户的索引；
-
所有商品的文档，可以组织在一起，称为商品的索引；
-
所有订单的文档，可以组织在一起，称为订单的索引；
因此，我们可以把索引当做是数据库中的表。
数据库的表会有约束信息，用来定义表的结构、字段的名称、类型等信息。因此，索引库中就有映射（mapping），是索引中文档的字段约束信息，类似表的结构约束。
三、使用IK分词器
3.1 IK分词器包含两种模式：
ik_smart: 智能语义切分
ik_max_word: 最细颗粒切分
3.2 拓宽词典
1）打开IK分词器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）重启elasticsearch
docker restart es
# 查看 日志
docker logs -f elasticsearchIK分词器有几种模式？
-
ik_smart：智能切分，粗粒度 -
ik_max_word：最细切分，细粒度
IK分词器如何拓展词条？如何停用词条？
-
利用config目录的
IkAnalyzer.cfg.xml文件添加拓展词典和停用词典 -
在词典中添加拓展词条或者停用词条
四、索引库操作
4.1 索引库操作
Index就类似数据库表，Mapping映射就类似表的结构。我们要向es中存储数据，必须先创建Index和Mapping
4.2.Mapping映射属性
Mapping是对索引库中文档的约束，常见的Mapping属性包括：
-
type：字段数据类型，常见的简单类型有：-
字符串：
text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址） -
数值：
long、integer、short、byte、double、float、 -
布尔：
boolean -
日期：
date -
对象：
object
-
-
index：是否创建索引，默认为true -
analyzer：使用哪种分词器 -
properties：该字段的子字段
4.3 索引库的CRUD
由于Elasticsearch采用的是Restful风格的API，因此其请求方式和路径相对都比较规范，而且请求参数也都采用JSON风格。
我们直接基于Kibana的DevTools来编写请求做测试，由于有语法提示，会非常方便。
4.3.1.创建索引库和映射
基本语法：
-
请求方式：
PUT -
请求路径：
/索引库名，可以自定义 -
请求参数：
mapping映射
PUT /索引库名称
{
"mappings": {
"properties": {
"字段名":{
"type": "text",
"analyzer": "ik_smart"
},
"字段名2":{
"type": "keyword",
"index": "false"
},
"字段名3":{
"properties": {
"子字段": {
"type": "keyword"
}
}
},
// ...略
}
}
}4.3.2.查询索引库
基本语法：
-
请求方式：GET
-
请求路径：/索引库名
-
请求参数：无
GET /索引库名4.3.3.修改索引库
倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这简直是灾难。因此索引库一旦创建，无法修改mapping。
虽然无法修改mapping中已有的字段，但是却允许添加新的字段到mapping中，因为不会对倒排索引产生影响。因此修改索引库能做的就是向索引库中添加新字段，或者更新索引库的基础属性。
PUT /索引库名/_mapping
{
"properties": {
"新字段名":{
"type": "integer"
}
}
}4.3.4.删除索引库
语法：
-
请求方式：DELETE
-
请求路径：/索引库名
-
请求参数：无
DELETE /索引库名总结
索引库操作有哪些？
-
创建索引库：PUT /索引库名
-
查询索引库：GET /索引库名
-
删除索引库：DELETE /索引库名
-
修改索引库，添加字段：PUT /索引库名/_mapping
五、文档操作
有了索引库，接下来就可以向索引库中添加数据了。Elasticsearch中的数据其实就是JSON风格的文档。操作文档自然保护增、删、改、查等几种常见操作，我们分别来学习。
5.1.新增文档
语法：
POST /索引库名/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
"字段3": {
"子属性1": "值3",
"子属性2": "值4"
},
}5.2.查询文档
根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把文档id带上。
语法：
GET /{索引库名称}/_doc/{id}5.3.删除文档
删除使用DELETE请求，同样，需要根据id进行删除：
语法：
DELETE /{索引库名}/_doc/id值5.4.修改文档
修改有两种方式：
-
全量修改：直接覆盖原来的文档
-
局部修改：修改文档中的部分字段
5.4.1.全量修改
全量修改是覆盖原来的文档，其本质是两步操作：
-
根据指定的id删除文档
-
新增一个相同id的文档
注意：如果根据id删除时，id不存在，第二步的新增也会执行，也就从修改变成了新增操作了。
PUT /{索引库名}/_doc/文档id
{
"字段1": "值1",
"字段2": "值2",
// ... 略
}5.4.2.局部修改
局部修改是只修改指定id匹配的文档中的部分字段。
POST /{索引库名}/_update/文档id
{
"doc": {
"字段名": "新的值",
}
}5.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 -
{ "field1" : "value1" }：则是要新增的文档内容
-
-
delete代表删除操作-
_index：指定索引库名 -
_id指定要操作的文档id
-
-
update代表更新操作-
_index：指定索引库名 -
_id指定要操作的文档id -
{ "doc" : {"field2" : "value2"} }：要更新的文档字段
-
5.6.总结
文档操作有哪些？
-
创建文档：
POST /{索引库名}/_doc/文档id { json文档 } -
查询文档：
GET /{索引库名}/_doc/文档id -
删除文档：
DELETE /{索引库名}/_doc/文档id -
修改文档：
-
全量修改：
PUT /{索引库名}/_doc/文档id { json文档 } -
局部修改：
POST /{索引库名}/_update/文档id { "doc": {字段}}
-
六、RestAPI
ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。
官方文档地址：
Elasticsearch Clients | Elastic
由于ES目前最新版本是8.8，提供了全新版本的客户端，老版本的客户端已经被标记为过时。而我们采用的是7.12版本，因此只能使用老版本客户端
4.1.初始化RestClient
在elasticsearch提供的API中，与elasticsearch一切交互都封装在一个名为RestHighLevelClient的类中，必须先完成这个对象的初始化，建立与elasticsearch的连接。
分为三步：
1）在item-service模块中引入es的RestHighLevelClient依赖：
<dependency>
<groupId>org.elasticsearch.client</groupId> <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>
2）因为SpringBoot默认的ES版本是7.17.10，所以我们需要覆盖默认的ES版本：
<properties>
<maven.compiler.source>11</maven.compiler.source> <maven.compiler.target>11</maven.compiler.target> <elasticsearch.version>7.12.1</elasticsearch.version> </properties>
3）初始化RestHighLevelClient：
初始化的代码如下：
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder( HttpHost.create("http://192.168.150.101:9200")
));
这里为了单元测试方便，我们创建一个测试类IndexTest，然后将初始化的代码编写在@BeforeEach方法中：
package com.hmall.item.es;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import java.io.IOException;
/**
* @Description: TODO
* @DateTime: 2024/8/5 21:53
**/
class ItemApplicationTest {
private RestHighLevelClient client;
@BeforeEach
void setUp(){
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.200.101:9200")
));
}
@Test
void testConnect(){
System.out.println(client);
}
/**
* 创建index -->创建表
*/
@Test
void testCreateIndex() throws IOException {
// 1.创建Request对象
CreateIndexRequest request = new CreateIndexRequest("items");
// 2.准备请求参数
request.source(MAPPING_TEMPLATE, XContentType.JSON);
// 3.发送请求
client.indices().create(request, RequestOptions.DEFAULT);
}
/**
* 删除index
* @throws IOException
*/
@Test
void testDeleteIndex() throws IOException {
// 1.创建Request对象
DeleteIndexRequest request = new DeleteIndexRequest("items");
// 2.发送请求
client.indices().delete(request,RequestOptions.DEFAULT);
}
/**
* 判断index是否存在
* @throws IOException
*/
@Test
void testExistsIndex() throws IOException {
// 1.创建request对象
GetIndexRequest request = new GetIndexRequest("items");
// 2.发送请求
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
System.out.println("exists = "+exists);
}
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
static final String MAPPING_TEMPLATE = "{\n" +
" \"mappings\": {\n" +
" \"properties\": {\n" +
" \"id\": {\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"name\":{\n" +
" \"type\": \"text\",\n" +
" \"analyzer\": \"ik_max_word\"\n" +
" },\n" +
" \"price\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"stock\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"image\":{\n" +
" \"type\": \"keyword\",\n" +
" \"index\": false\n" +
" },\n" +
" \"category\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"brand\":{\n" +
" \"type\": \"keyword\"\n" +
" },\n" +
" \"sold\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"commentCount\":{\n" +
" \"type\": \"integer\"\n" +
" },\n" +
" \"isAD\":{\n" +
" \"type\": \"boolean\"\n" +
" },\n" +
" \"updateTime\":{\n" +
" \"type\": \"date\"\n" +
" }\n" +
" }\n" +
" }\n" +
"}"
;
}4.2.总结
JavaRestClient操作elasticsearch的流程基本类似。核心是client.indices()方法来获取索引库的操作对象。
索引库操作的基本步骤：
-
初始化
RestHighLevelClient -
创建XxxIndexRequest。XXX是
Create、Get、Delete -
准备请求参数（
Create时需要，其它是无参，可以省略） -
发送请求。调用
RestHighLevelClient#indices().xxx()方法，xxx是create、exists、delete
六、RestClient操作文档
索引库准备好以后，就可以操作文档了。为了与索引库操作分离，我们再次创建一个测试类，做两件事情：
-
初始化RestHighLevelClient
-
我们的商品数据在数据库，需要利用IHotelService去查询，所以注入这个接口
package com.hmall.item.es;
import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSONUtil;
import com.baomidou.mybatisplus.extension.plugins.pagination.Page;
import com.hmall.common.utils.CollUtils;
import com.hmall.item.domain.dto.ItemDoc;
import com.hmall.item.domain.po.Item;
import com.hmall.item.service.IItemService;
import lombok.extern.slf4j.Slf4j;
import org.apache.http.HttpHost;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestClient;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.xcontent.XContentType;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import java.io.IOException;
import java.util.List;
/**
* @Description: TODO
* @DateTime: 2024/8/5 22:11
**/
@SpringBootTest(properties = "spring.profiles.active=local")
@Slf4j
public class DocumentTest {
private RestHighLevelClient client;
@Autowired
private IItemService itemService;
@BeforeEach
void setUp(){
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.200.101:9200")
));
}
@Test
void testAddDocument() throws IOException {
// 1.根据id查找对应的商品数据 317578
Item item = itemService.getById(317578L);
// 2.转换类型
ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);
// 3.将itemDoc转为json
String 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);
}
@Test
void testGetDocumentById() throws IOException {
// 1.创建request对象
GetRequest request = new GetRequest("items", "317578");
// 2.发送请求
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.解析结果
String json = response.getSourceAsString();
ItemDoc doc = JSONUtil.toBean(json, ItemDoc.class);
System.out.println(json);
}
@Test
void testDeleteDocumentById() throws IOException {
// 1.创建request对象
DeleteRequest request = new DeleteRequest("items", "317578");
// 2.执行
client.delete(request,RequestOptions.DEFAULT);
}
/**
* 修改
* @throws IOException
*/
@Test
void testUpdateDocument() throws IOException {
// 1.准备request
UpdateRequest request = new UpdateRequest("items", "317578");
// 2.发送请求参数
request.doc(
"price",588,
"commentCount",1
);
// 3.发送请求参数
client.update(request,RequestOptions.DEFAULT);
}
/**
* 批量插入
* @throws IOException
*/
@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.创建Request
BulkRequest request = new BulkRequest("items");
// 2.准备参数，添加多个新增的Request
for (Item item : items) {
// 2.1.转换为文档类型ItemDTO
ItemDoc 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++;
}
}
@AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
6.1.小结
文档操作的基本步骤：
-
初始化
RestHighLevelClient -
创建XxxRequest。
-
XXX是
Index、Get、Update、Delete、Bulk
-
-
准备参数（
Index、Update、Bulk时需要） -
发送请求。
-
调用
RestHighLevelClient#.xxx()方法，xxx是index、get、update、delete、bulk
-
-
解析结果（
Get时需要）
340
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
