当前位置： 首页 > news >正文

黑马商城day8-ES01

news 2025/11/1 11:24:31

1.ES入门

黑马商城作为一个电商项目，商品的搜索肯定是访问频率最高的页面之一。目前搜索功能是基于数据库的模糊搜索来实现的，存在很多问题。

首先，查询效率较低。

由于数据库模糊查询不走索引，在数据量较大的时候，查询性能很差。黑马商城的商品表中仅仅有不到9万条数据，基于数据库查询时，搜索接口的表现如图：改为基于搜索引擎后，查询表现如下：

需要注意的是，数据库模糊查询随着表数据量的增多，查询性能的下降会非常明显，而搜索引擎的性能则不会随着数据增多而下降太多。目前仅10万不到的数据量差距就如此明显，如果数据量达到百万、千万、甚至上亿级别，这个性能差距会非常夸张。

其次，功能单一

数据库的模糊搜索功能单一，匹配条件非常苛刻，必须恰好包含用户搜索的关键字。而在搜索引擎中，用户输入出现个别错字，或者用拼音搜索、同义词搜索都能正确匹配到数据。

综上，在面临海量数据的搜索，或者有一些复杂搜索需求的时候，推荐使用专门的搜索引擎来实现搜索功能。

目前全球的搜索引擎技术排名如下：elasticsearch是一款非常强大的开源搜索引擎，支持的功能非常多，例如：

学习目标：

  • 理解倒排索引原理

  • 会使用IK分词器

  • 理解索引库Mapping映射的属性含义

  • 能创建索引库及映射

  • 能实现文档的CRUD

1.1.认识和安装

Lucene是一个Java语言的搜索引擎类库，是Apache公司的顶级项目，由DougCutting于1999年研发。

官网地址：https://lucene.apache.org/ 。

Lucene的优势：

  • 易扩展
  • 高性能（基于倒排索引）

2004年Shay Banon基于Lucene开发了Compass

2010年Shay Banon 重写了Compass，取名为Elasticsearch。

官网地址: https://www.elastic.co/cn/ ，目前最新的版本是：8.x.x

elasticsearch具备下列优势：

  • 支持分布式，可水平扩展
  • 提供Restful接口，可被任何语言调用

Elasticsearch是由elastic公司开发的一套搜索引擎技术，它是elastic技术栈中的一部分。完整的技术栈包括：

  • Elasticsearch：用于数据存储、计算和搜索

  • Logstash/Beats：用于数据收集

  • Kibana：用于数据可视化

整套技术栈被称为ELK，经常用来做日志收集、系统监控和状态分析等等：整套技术栈的核心就是用来存储、搜索、计算的Elasticsearch，因此我们接下来学习的核心也是Elasticsearch。

如果只是想做个简单的搜索比如商城/百度一类，而不是分析日志等信息，就可以只装ES。

要安装的内容包含2部分：

  • elasticsearch：存储、搜索和运算

  • kibana：图形化展示

首先Elasticsearch不用多说，是提供核心的数据存储、搜索、分析功能的。

然后是Kibana，Elasticsearch对外提供的是Restful风格的API，任何操作都可以通过发送http请求来完成。不过http请求的方式、路径、还有请求参数的格式都有严格的规范。这些规范我们肯定记不住，因此我们要借助于Kibana这个服务。

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

  • 对Elasticsearch数据的搜索、展示

  • 对Elasticsearch数据的统计、聚合，并形成图形化报表、图形

  • 对Elasticsearch的集群状态监控

  • 它还提供了一个开发控制台（DevTools），在其中对Elasticsearch的Restful的API接口提供了语法提示

通过下面的Docker命令即可安装单机版本的elasticsearch：

docker run -d \--name es \-e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \ 底层是用Java写的，这里是设置java虚拟机-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

注意，这里我们采用的是elasticsearch的7.12.1版本，由于8以上版本的JavaAPI变化很大，在企业中应用并不广泛，企业中应用较多的还是8以下的版本。安装完成后，访问9200端口，即可看到响应的Elasticsearch服务的基本信息：通过下面的Docker命令，即可部署Kibana：

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

安装完成后，直接访问5601端口，即可看到控制台页面：

安装kibana主要是用控制台去发请求，因为请求可能会很多我们不方便记住，同时参数也不方便记，但是控制台会为我们展示这些信息。

1.2.倒排索引

elasticsearch之所以有如此高性能的搜索表现，正是得益于底层的倒排索引技术。那么什么是倒排索引呢？

倒排索引的概念是基于MySQL这样的正向索引而言的。

1.正向索引

传统数据库（如MySQL）采用正向索引，例如给下表（tb_goods）中的id创建索引：

id

title

price

1

小米手机

3499

2

华为手机

4999

3

华为小米充电器

49

4

小米手环

49

...

...

...

其中的id字段已经创建了索引，由于索引底层采用了B+树结构，因此我们根据id搜索的速度会非常快。但是其他字段例如title，只在叶子节点上存在。

所以如果要以title搜索，那只能去遍历效率很低。

比如用户的SQL语句为：

select * from tb_goods where title like '%手机%';

那搜索的大概流程如图：

2.倒排索引

elasticsearch采用倒排索引：

  • 文档（document）：每条数据就是一个文档
  • 词条（term）：文档按照语义分成的词语

创建倒排索引是对正向索引的一种特殊处理和应用，流程如下：

  • 将每一个文档的数据利用分词算法根据语义拆分，得到一个个词条

  • 创建表，每行数据包括词条、词条所在文档id、位置等信息

  • 因为词条唯一性，可以给词条创建正向索引

后续搜索时由于词条具有索引，所以搜索速度会很快，从词条处拿到了id，id也具有索引，两次搜索都具有索引，搜索速度会很快。

3.总结：

什么是文档和词条？

  • 每一条数据就是一个文档
  • 对文档中的内容分词，得到的词语就是词条

什么是正向索引？

  • 基于文档id创建索引。根据id查询快，但是查询词条时必须先找到文档，而后判断是否包含词条

什么是倒排索引？

  • 对文档内容分词，对词条创建索引，并记录词条所在文档的id。查询时先根据词条查询到文档id，而后根据文档id查询文档

1.3.IK分词器

中文分词往往需要根据语义分析，比较复杂，这就需要用到中文分词器，例如IK分词器。IK分词器是林良益在2006年开源发布的，其采用的正向迭代最细粒度切分算法一直沿用至今。

其安装的方式也比较简单，只要将资料提供好的分词器放入elasticsearch的插件目录即可：最后，重启es容器

1.3.1.使用IK分词器

IK分词器包含两种模式：

  • ik_smart：智能语义切分

  • ik_max_word：最细粒度切分

我们在Kibana的DevTools上来测试分词器，首先测试Elasticsearch官方提供的标准分词器：

POST /_analyze
{"analyzer": "standard", //标准英文原版分词器"text": "黑马程序员学习java太棒了"
}

结果如下：

{"tokens" : [{"token" : "黑","start_offset" : 0,"end_offset" : 1,"type" : "<IDEOGRAPHIC>","position" : 0},{"token" : "马","start_offset" : 1,"end_offset" : 2,"type" : "<IDEOGRAPHIC>","position" : 1},{"token" : "程","start_offset" : 2,"end_offset" : 3,"type" : "<IDEOGRAPHIC>","position" : 2},{"token" : "序","start_offset" : 3,"end_offset" : 4,"type" : "<IDEOGRAPHIC>","position" : 3},{"token" : "员","start_offset" : 4,"end_offset" : 5,"type" : "<IDEOGRAPHIC>","position" : 4},{"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}]
}

可以看到，标准分词器智能1字1词条，无法正确对中文做分词。

我们再测试IK分词器：

POST /_analyze
{"analyzer": "ik_smart",//智能语义"text": "黑马程序员学习java太棒了"
}

结果如下：

{"tokens" : [{"token" : "黑马","start_offset" : 0,"end_offset" : 2,"type" : "CN_WORD","position" : 0},{"token" : "程序员","start_offset" : 2,"end_offset" : 5,"type" : "CN_WORD","position" : 1},{"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最细力度：

POST /_analyze
{"analyzer": "ik_max_word","text": "黑马程序员学习java太棒了"
}
{"tokens" : [{"token" : "黑马","start_offset" : 0,"end_offset" : 2,"type" : "CN_WORD","position" : 0},{"token" : "程序员","start_offset" : 2,"end_offset" : 5,"type" : "CN_WORD","position" : 1},{"token" : "程序","start_offset" : 2,"end_offset" : 4,"type" : "CN_WORD","position" : 2},{"token" : "员","start_offset" : 4,"end_offset" : 5,"type" : "CN_CHAR","position" : 3},{"token" : "学习","start_offset" : 5,"end_offset" : 7,"type" : "CN_WORD","position" : 4},{"token" : "java","start_offset" : 7,"end_offset" : 11,"type" : "ENGLISH","position" : 5},{"token" : "太棒了","start_offset" : 11,"end_offset" : 14,"type" : "CN_WORD","position" : 6},{"token" : "太棒","start_offset" : 11,"end_offset" : 13,"type" : "CN_WORD","position" : 7},{"token" : "了","start_offset" : 13,"end_offset" : 14,"type" : "CN_CHAR","position" : 8}]
}

可以发现更细了。

1.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，再次测试，可以发现传智播客和泰裤辣都正确分词了：

POST /_analyze
{"analyzer": "ik_max_word","text": "传智播客开设大学,真的泰裤辣！"
}
{"tokens" : [{"token" : "传智播客","start_offset" : 0,"end_offset" : 4,"type" : "CN_WORD","position" : 0},{"token" : "开设","start_offset" : 4,"end_offset" : 6,"type" : "CN_WORD","position" : 1},{"token" : "大学","start_offset" : 6,"end_offset" : 8,"type" : "CN_WORD","position" : 2},{"token" : "真的","start_offset" : 9,"end_offset" : 11,"type" : "CN_WORD","position" : 3},{"token" : "泰裤辣","start_offset" : 11,"end_offset" : 14,"type" : "CN_WORD","position" : 4}]
}

总结

分词器的作用是什么？

  • 创建倒排索引时，对文档分词
  • 用户搜索时，对输入的内容分词

IK分词器有几种模式？

  • ik_smart：智能切分，粗粒度
  • ik_max_word：最细切分，细粒度IK分词器

如何拓展分词器词库中的词条？

  • 利用config目录的IkAnalyzer.cfg.xml文件添加拓展词典
  • 在词典中添加拓展词条
     

1.4.基础概念

1.4.1.文档和字段

elasticsearch中的文档数据会被序列化为json格式后存储在elasticsearch中。

因此，原本数据库中的一行数据就是ES中的一个JSON文档；而数据库中每行数据都包含很多列，这些列就转换为JSON文档中的字段（Field）。

1.4.2.索引和映射

但是，随着业务发展，需要在es中存储的文档也会越来越多，比如有商品的文档、用户的文档、订单文档等等：

所有文档都散乱存放显然非常混乱，也不方便管理。

因此，我们要将类型相同的文档集中在一起管理，称为索引（Index）为了区别mysql中的索引，一般也叫索引库。例如：

  • 所有用户文档，就可以组织在一起，称为用户的索引；

  • 所有商品的文档，可以组织在一起，称为商品的索引；

  • 所有订单的文档，可以组织在一起，称为订单的索引；

因此，我们可以把索引当做是数据库中的表。

数据库的表会有约束信息，用来定义表的结构、字段的名称、类型等信息。因此，索引库中就有映射（mapping），是索引中文档的字段约束信息，类似表的结构约束。

1.4.3.mysql与elasticsearch

MySQL

Elasticsearch

说明

Table

Index

索引(index)，就是文档的集合，类似数据库的表(table)

Row

Document

文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式

Column

Field

字段（Field），就是JSON文档中的字段，类似数据库中的列（Column）

Schema

Mapping

Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）

SQL

DSL

DSL是elasticsearch提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD

如图：

那是不是说，我们学习了elasticsearch就不再需要mysql了呢？

并不是如此，两者各自有自己的擅长之处：

  • Mysql：擅长事务类型操作，可以确保数据的安全和一致性

  • Elasticsearch：擅长海量数据的搜索、分析、计算

因此在企业中，往往是两者结合使用：

  • 对安全性要求较高的写操作，使用mysql实现

  • 对查询性能要求较高的搜索需求，使用elasticsearch实现

  • 两者再基于某种方式，实现数据的同步，保证一致性

2.索引库操作

Index就类似数据库表，Mapping映射就类似表的结构。我们要向es中存储数据，必须先创建Index和Mapping

2.1.Mapping映射属性

Mapping是对索引库中文档的约束，常见的Mapping属性包括：

  • type：字段数据类型，常见的简单类型有：

    • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）

    • 数值：long、integer、short、byte、double、float、

    • 布尔：boolean

    • 日期：date

    • 对象：object

  • index：是否创建索引，默认为true

  • analyzer：使用哪种分词器

  • properties：该字段的子字段

例如下面的json文档：

{"age": 21,"weight": 52.1,"isMarried": false,"info": "黑马程序员Java讲师","email": "zy@itcast.cn","score": [99.1, 99.5, 98.9],"name": {"firstName": "云","lastName": "赵"}
}

对应的每个字段映射（Mapping）：

字段名

字段类型

类型说明

是否

参与搜索

是否

参与分词

分词器

age

integer

整数

——

weight

float

浮点数

——

isMarried

boolean

布尔

——

info

text

字符串，但需要分词

IK

email

keyword

字符串，但是不分词

——

score

float

只看数组中元素类型

——

name

firstName

keyword

字符串，但是不分词

——

lastName

keyword

字符串，但是不分词

——

2.2.索引库的CRUD

由于Elasticsearch采用的是Restful风格的API，因此其请求方式和路径相对都比较规范，而且请求参数也都采用JSON风格。

我们直接基于Kibana的DevTools来编写请求做测试，由于有语法提示，会非常方便。

#创建索引库并设置mapping映射
PUT /helma
{"mappings": {"properties": {"info":{"type": "text","analyzer": "ik_smart"},"email":{"type": "keyword","index": false},"name":{"type": "object","properties": {"firstName":{"type": "keyword"},"lasttName":{"type": "keyword"}}}}}
}#查询索引库
Get /helma#删除索引库
DELETE /helma#修改索引库，新增字段
PUT /helma/_mapping
{"properties":{"age":{"type": "byte"}}
}

2.2.1.创建索引库和映射

基本语法：

  • 请求方式：PUT

  • 请求路径：/索引库名，可以自定义

  • 请求参数：mapping映射

格式：

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

2.2.2.查询索引库

基本语法：

  • 请求方式：GET

  • 请求路径：/索引库名

  • 请求参数：无

2.2.3.修改索引库

倒排索引结构虽然不复杂，但是一旦数据结构改变（比如改变了分词器），就需要重新创建倒排索引，这简直是灾难。因此索引库一旦创建，无法修改mapping。

虽然无法修改mapping中已有的字段，但是却允许添加新的字段到mapping中，因为不会对倒排索引产生影响。因此修改索引库能做的就是向索引库中添加新字段，或者更新索引库的基础属性。

语法说明：

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

2.2.4.删除索引库

语法：

  • 请求方式：DELETE

  • 请求路径：/索引库名

  • 请求参数：无

索引库操作有哪些？

  • 创建索引库：PUT /索引库名

  • 查询索引库：GET /索引库名

  • 删除索引库：DELETE /索引库名

  • 修改索引库，添加字段：PUT /索引库名/_mapping

3.文档操作

有了索引库，接下来就可以向索引库中添加数据了。

Elasticsearch中的数据其实就是JSON风格的文档。操作文档自然保护增、删、改、查等几种常见操作。

3.1.新增文档

语法：

POST /索引库名/_doc/文档id
{"字段1": "值1","字段2": "值2","字段3": {"子属性1": "值3","子属性2": "值4"},
}

示例：

POST /heima/_doc/1
{"info": "黑马程序员Java讲师","email": "zy@itcast.cn","name": {"firstName": "云","lastName": "赵"}
}

响应：

3.2.查询文档

根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把文档id带上。

语法：

GET /{索引库名称}/_doc/{id}

示例：

GET /heima/_doc/1

查看结果：

3.3.删除文档

删除使用DELETE请求，同样，需要根据id进行删除：

语法：

DELETE /{索引库名}/_doc/id值

示例：

DELETE /heima/_doc/1

结果：

3.4.修改文档

修改有两种方式：

  • 全量修改：直接覆盖原来的文档

  • 局部修改：修改文档中的部分字段

3.4.1.全量修改

全量修改是覆盖原来的文档，其本质是两步操作：

  • 根据指定的id删除文档

  • 新增一个相同id的文档

注意：如果根据id删除时，id不存在，第二步的新增也会执行，也就从修改变成了新增操作了。

语法：

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

示例：

PUT /heima/_doc/1
{"info": "黑马程序员高级Java讲师","email": "zy@itcast.cn","name": {"firstName": "云","lastName": "赵"}
}

由于id为1的文档已经被删除，所以第一次执行时，得到的反馈是created：

所以如果执行第2次时，得到的反馈则是updated：

3.4.2.局部修改

局部修改是只修改指定id匹配的文档中的部分字段。

语法：

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

示例：

POST /heima/_update/1
{"doc": {"email": "ZhaoYun@itcast.cn"}
}

执行结果：

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

    • { "field1" : "value1" }：则是要新增的文档内容

  • delete代表删除操作

    • _index：指定索引库名

    • _id指定要操作的文档id

  • update代表更新操作

    • _index：指定索引库名

    • _id指定要操作的文档id

    • { "doc" : {"field2" : "value2"} }：要更新的文档字段

示例，批量新增：

POST /_bulk
{"index": {"_index":"heima", "_id": "3"}}
{"info": "黑马程序员C++讲师", "email": "ww@itcast.cn", "name":{"firstName": "五", "lastName":"王"}}
{"index": {"_index":"heima", "_id": "4"}}
{"info": "黑马程序员前端讲师", "email": "zhangsan@itcast.cn", "name":{"firstName": "三", "lastName":"张"}}

批量删除：

POST /_bulk
{"delete":{"_index":"heima", "_id": "3"}}
{"delete":{"_index":"heima", "_id": "4"}}

3.6.总结

文档操作有哪些？

  • 创建文档：POST /{索引库名}/_doc/文档id { json文档 }

  • 查询文档：GET /{索引库名}/_doc/文档id

  • 删除文档：DELETE /{索引库名}/_doc/文档id

  • 修改文档：

    • 全量修改：PUT /{索引库名}/_doc/文档id { json文档 }

    • 局部修改：POST /{索引库名}/_update/文档id { "doc": {字段}}

4.RestAPI

ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES。

官方文档地址：

https://www.elastic.co/guide/en/elasticsearch/client/index.html

由于ES目前最新版本是8.8，提供了全新版本的客户端，老版本的客户端已经被标记为过时。而我们采用的是7.12版本，因此只能使用老版本客户端：然后选择7.12版本，HighLevelRestClient版本：

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方法中：

public class IndexTest {private RestHighLevelClient client;@BeforeEachvoid setUp() {this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.150.101:9200")));}@Testvoid testConnect() {System.out.println(client);}@AfterEachvoid tearDown() throws IOException {this.client.close();}
}

4.1.创建索引库

由于要实现对商品搜索，所以我们需要将商品添加到Elasticsearch中，不过需要根据搜索业务的需求来设定索引库结构，而不是一股脑的把MySQL数据写入Elasticsearch.

4.1.1.Mapping映射

搜索页面的效果如图所示：

实现搜索功能需要的字段包括三大部分：

  • 搜索过滤字段

    • 分类

    • 品牌

    • 价格

  • 排序字段

    • 默认：按照更新时间降序排序

    • 销量

    • 价格

  • 展示字段

    • 商品id：用于点击后跳转

    • 图片地址

    • 是否是广告推广商品

    • 名称

    • 价格

    • 评价数量

    • 销量

对应的商品表结构如下，索引库无关字段已经划掉：结合数据库表结构，以上字段对应的mapping映射属性如下：

因此，最终我们的索引库文档结构应该是这样：

PUT /items
{"mappings": {"properties": {"id": {"type": "keyword"},"name":{"type": "text","analyzer": "ik_max_word"},"price":{"type": "integer"},"stock":{"type": "integer"},"image":{"type": "keyword","index": false},"category":{"type": "keyword"},"brand":{"type": "keyword"},"sold":{"type": "integer"},"commentCount":{"type": "integer","index": false},"isAD":{"type": "boolean"},"updateTime":{"type": "date"}}}
}

4.1.2.创建索引

创建索引库的API如下：

代码分为三步：

  • 1）创建Request对象。

    • 因为是创建索引库的操作，因此Request是CreateIndexRequest。

  • 2）添加请求参数

    • 其实就是Json格式的Mapping映射参数。因为json字符串很长，这里是定义了静态字符串常量MAPPING_TEMPLATE，让代码看起来更加优雅。

  • 3）发送请求

    • client.indices()方法的返回值是IndicesClient类型，封装了所有与索引库操作有关的方法。例如创建索引、删除索引、判断索引是否存在等

在item-service中的IndexTest测试类中，具体代码如下：

@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);
}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.删除索引库

删除索引库的请求非常简单：

DELETE /hotel

与创建索引库相比：

  • 请求方式从PUT变为DELTE

  • 请求路径不变

  • 无请求参数

所以代码的差异，注意体现在Request对象上。流程如下：

  • 1）创建Request对象。这次是DeleteIndexRequest对象

  • 2）准备参数。这里是无参，因此省略

  • 3）发送请求。改用delete方法

在item-service中的IndexTest测试类中，编写单元测试，实现删除索引：

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

4.3.获取和判断索引库是否存在

判断索引库是否存在，本质就是查询，对应的请求语句是：

GET /hotel

因此与删除的Java代码流程是类似的，流程如下：

  • 1）创建Request对象。这次是GetIndexRequest对象

  • 2）准备参数。这里是无参，直接省略

  • 3）发送请求。改用exists方法

  • 4）获取索引库，改用get方法

@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 ? "索引库已经存在！" : "索引库不存在！");// 4.获取索引库client.indices().get(request, RequestOptions.DEFAULT);
}

4.4.总结

索引库操作的基本步骤：

  1. 创建XxxIndexRequest。XXX是Create、Get、Delete
  2. 准备请求参数（ Create时需要） 发送请求。
  3. 调用RestHighLevelClient#indices().xxx()方法，xxx是create、get(exists)、delete

5.RestClient操作文档

5.1.新增文档

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

新增文档的JavaAPI如下：

总的来说，文档操作感觉上和索引库操作是类似的。

因为这里我们已经创建好items索引库和mapping约束了，所以这个测试方法我们希望将mysql数据库中的数据存到ES索引库中。

准备：

1.根据mapping约束，创建ItemDoc实体，将不需要的属性去除掉。

@Data
@ApiModel(description = "索引库实体")
public class ItemDoc{@ApiModelProperty("商品id")private String id;@ApiModelProperty("商品名称")private String name;@ApiModelProperty("价格（分）")private Integer price;@ApiModelProperty("商品图片")private String image;@ApiModelProperty("类目名称")private String category;@ApiModelProperty("品牌名称")private String brand;@ApiModelProperty("销量")private Integer sold;@ApiModelProperty("评论数")private Integer commentCount;@ApiModelProperty("是否是推广广告，true/false")private Boolean isAD;@ApiModelProperty("更新时间")private LocalDateTime updateTime;
}

测试：

1.准备文档数据。注入itemService获取item对象，通过BeanUtil复制属性获得ItemDoc对象。

2.准备Request对象。创建IndexRequest，声明索引库和文档id

3.准备请求参数。通过JSONUtil将ItemDoc对象转为Json格式数据。

4.发送请求。

    @Testvoid testIndexDoc() throws IOException {//0.准备文档数据Item item = itemService.getById(1178447L);ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);//1.准备Request对象IndexRequest request = new IndexRequest("items").id(itemDoc.getId());//2.准备请求参数request.source(JSONUtil.toJsonStr(itemDoc), XContentType.JSON);//3.发送请求client.index(request, RequestOptions.DEFAULT);}

5.2.查询文档

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

查询文档的JavaAPI如下：

实现：

1.创建Request对象

2.发送请求

3.获取响应json数据，使用JsonUtil将json数据转为实体类对象。

@Testvoid testGetDoc() throws IOException {GetRequest request = new GetRequest("items").id("1178447");GetResponse response = client.get(request, RequestOptions.DEFAULT);String json = response.getSourceAsString();ItemDoc itemDoc = JSONUtil.toBean(json, ItemDoc.class);System.out.println(itemDoc);}

5.3.删除文档

删除的请求语句如下：

DELETE /hotel/_doc/{id}

与查询相比，仅仅是请求方式从DELETE变成GET，可以想象Java代码应该依然是2步走：

  • 1）准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id

  • 2）发送请求。因为是删除，所以是client.delete()方法

@Test
void testDeleteDocument() throws IOException {// 1.准备Request，两个参数，第一个是索引库名，第二个是文档idDeleteRequest request = new DeleteRequest("item", "100002644680");// 2.发送请求client.delete(request, RequestOptions.DEFAULT);
}

5.4.修改文档

修改我们讲过两种方式：

  • 全量修改：本质是先根据id删除，再新增

  • 局部修改：修改文档中的指定字段值

在RestClient的API中，全量修改与新增的API完全一致，判断依据是ID：

  • 如果新增时，ID已经存在，则修改

  • 如果新增时，ID不存在，则新增

这里不再赘述，我们主要关注局部修改的API即可。

局部修改的请求语法如下：

POST /{索引库名}/_update/{id}
{"doc": {"字段名": "字段值","字段名": "字段值"}
}

与之前类似，也是三步走：

  • 1）准备Request对象。这次是修改，所以是UpdateRequest

  • 2）准备参数。也就是JSON文档，里面包含要修改的字段

  • 3）更新文档。这里调用client.update()方法

@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);
}

5.5.批量导入文档

在之前的案例中，我们都是操作单个文档。而数据库中的商品数据实际会达到数十万条，某些项目中可能达到数百万条。

我们如果要将这些数据导入索引库，肯定不能逐条导入，而是采用批处理方案。常见的方案有：

  • 利用Logstash批量导入

    • 需要安装Logstash

    • 对数据的再加工能力较弱

    • 无需编码，但要学习编写Logstash导入配置

  • 利用JavaAPI批量导入

    • 需要编码，但基于JavaAPI，学习成本低

    • 更加灵活，可以任意对数据做再加工处理后写入索引库

bulk操作就是将很多个Index、Delete、Update请求添加到BulkRequest中，然后统一执行。因此Bulk中添加了多个IndexRequest，就是批量新增功能了。示例：

@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);
}

当我们要导入商品数据时，由于商品数量达到数十万，因此不可能一次性全部导入。建议采用循环遍历方式，每次导入1000条左右的数据。

item-service的DocumentTest测试类中，编写单元测试：

@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++;}
}

http://www.dtcms.com/a/554019.html

相关文章：

  • 创意网站建设公司阿里云宝塔面板一键安装wordpress
  • F043 vue+flask天气预测可视化系统大数据（浅色版）+机器学习+管理端+爬虫+超酷界面+顶级可视化水平
  • 电脑无法识别WiFi 7路由器的解决方式
  • 海南网站推广微商目前十大火爆产品
  • Nestjs框架: 微服务架构实践与技术选型指南
  • 网络请求完整指南 - 从原理到实践
  • PHP网站建设项目经验动态wordpress动态主题
  • 企业网站建设项目描述saas小程序开发
  • 各大门户网站怎么做推广如何做网站 优帮云
  • Python在云计算中的应用：AWS Lambda函数实战
  • Spring Cloud OpenFeign进行服务间调用时，传递自定义的请求头信息及报错解决
  • 基于单片机的 AI 智能快递柜设计与实现
  • 【医学影像 AI】视网膜图像多类别分割中的“段内误分类”
  • python3.13安装教程（附安装包），【2025】python3.13安装图文教程
  • 深圳专业建站多少钱线上渠道推广
  • ROS开发中`laser_scan_matcher`节点启动失败问题的分析与解决
  • 南昌装修网站建设菠菜网站的代理怎么做
  • c++调用客户端库与kafka交互
  • 用Liunx service方式管理SuperMap iServer
  • 邢台网站设计哪家专业wordpress主题添加后台设置选项
  • 京东网站建设的策划书如何做120急救网站
  • 佛山新网站建设服务安卓开发是做什么的
  • 普通园区摄像头如何将视频传输至云端平台
  • HDMI接口与串口：核心知识点解析及全方位区别对比
  • sql server 备份恢复全备和日志备份时间相近恢复失败
  • 回溯剪枝trick
  • 网页设计与制作用什么软件做北京公司排名seo
  • 什么伪原创网站好深圳全面放开
  • 【.NET】依赖注入浅显解释
  • IDEA连接MySQL服务器数据库指南