【从0到1学Elasticsearch】Elasticsearch从入门到精通（上）

黑马商城作为一个电商项目，商品的搜索肯定是访问频率最高的页面之一。目前搜索功能是基于数据库的模糊搜索来实现的，存在很多问题。
首先，查询效率较低。
由于数据库模糊查询不走索引，在数据量较大的时候，查询性能很差。
需要注意的是，数据库模糊查询随着表数据量的增多，查询性能的下降会非常明显，而搜索引擎的性能则不会随着数据增多而下降太多。目前仅10万不到的数据量差距就如此明显，如果数据量达到百万、千万、甚至上亿级别，这个性能差距会非常夸张。
其次，功能单一，数据库的模糊搜索匹配条件非常苛刻，例如，当我们需要查询java基础课程的时候，如果按照这种查询方式，我们查询出来的就只能是（---------java基础课程--------）前后匹配，那么如果一个店铺售卖的名为，（java课程，帮助你打好java基础）那么这个店铺售卖的东西就不会被搜索出来

目前全球的搜索引擎技术排名如下：

Elasticsearch功能有很多

• 1 例如github上的代码搜索
• 2 商品信息搜索
• 3 解决方案搜搜哦
• 4 附近商铺，打车搜索
• …

初识Elasticsearch

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

• Elasticsearch：用于数据存储、计算和搜索
• Logstash/Beats：用于数据收集
• Kibana：用于数据可视化

安装Elasticsearch

我们依旧采用的是docker安装，简单方便

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端口可以看到基本信息

安装Kibana

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

安装完成之后访问5601端口，可以看到控制台页面

倒排索引

elasticsearch之所以有如此高性能的搜索表现，正是得益于底层的倒排索引技术。我们首先来看看什么是正向索引。

正向索引

例如我们在mysql当中有一张goods的表

id	title	price
1	小米手机	3499
2	华为手机	4999
3	华为小米充电器	49
4	小米手环	49
…	…	…

其中的id字段已经创建了索引，由于索引底层采用了B+树结构，因此我们根据id搜索的速度会非常快。但是其他字段例如title，只在叶子节点上存在。
因此要根据title搜索的时候只能遍历树中的每一个叶子节点，判断title数据是否符合要求。

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

流程如下

说明：

• 1）检查到搜索条件为like ‘%手机%’，需要找到title中包含手机的数据
• 2）逐条遍历每行数据（每个叶子节点），比如第1次拿到id为1的数据
• 3）判断数据中的title字段值是否符合条件
• 4）如果符合则放入结果集，不符合则丢弃
• 5）回到步骤1

综上所述，如果我们根据有索引的id进行查询，那么查询效率就会非常高，但是如果搜索条件为模糊匹配时，由于索引无法生效，导致从索引查询退化为全表扫描，效率很差。
因此，正向索引适合于根据索引字段的精确搜索，不适合基于部分词条的模糊匹配。
而倒排索引恰好解决的就是根据部分词条模糊匹配的问题。

倒排索引

倒排索引中有两个非常重要的概念：

• 文档（Document）：用来搜索的数据，其中的每一条数据就是一个文档。例如一个网页、一个商品信息
• 词条（Term）：对文档数据或用户搜索数据，利用某种算法分词，得到的具备含义的词语就是词条。例如：我是中国人，就可以分为：我、是、中国人、中国、国人这样的几个词条

倒排索引的搜索流程如下（以搜索"华为手机"为例），如图：

流程描述：
1）用户输入条件"华为手机"进行搜索。
2）对用户输入条件分词，得到词条：华为、手机。
3）拿着词条在倒排索引中查找（由于词条有索引，查询效率很高），即可得到包含词条的文档id：1、2、3。
4）拿着文档id到正向索引中查找具体文档即可（由于id也有索引，查询效率也很高）。

虽然要先查询倒排索引，再查询倒排索引，但是无论是词条、还是文档id都建立了索引，查询速度非常快！无需全表扫描。

基础概念

elasticsearch是面向文档（Document）存储的，可以是数据库中的一条商品数据，一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中：

在mysq当中数据存储方式如下：

但是在es当中如下

{"id": 1,"title": "小米手机","price": 3499
}
{"id": 2,"title": "华为手机","price": 4999
}
{"id": 3,"title": "华为小米充电器","price": 49
}
{"id": 4,"title": "小米手环","price": 299
}

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

索引和映射

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

所有文档都散乱存放显然非常混乱，也不方便管理。
因此，我们要将类型相同的文档集中在一起管理，称为索引（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
}

Mysql与Es

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实现
• 两者再基于某种方式，实现数据的同步，保证一致性

IK分词器

爱坤分词器（露出鸡脚了），es关键的就是倒排索引，而倒排索引依赖对文档内部的词进行分词，而分词则需要高效、精准的分词算法，IK分词器就是这样一个中文分词算法。

安装IK分词器

同样是docker
方案1：在线安装

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

方案2：离线安装
首先，查看之前安装的Elasticsearch容器的plugins数据卷目录：

docker volume inspect es-plugins

[{"CreatedAt": "2024-11-06T10:06:34+08:00","Driver": "local","Labels": null,"Mountpoint": "/var/lib/docker/volumes/es-plugins/_data","Name": "es-plugins","Options": null,"Scope": "local"}
]

可以看到elasticsearch的插件挂载到了/var/lib/docker/volumes/es-plugins/_data这个目录。我们需要把IK分词器上传至这个目录。
上传完成之后重启es容器

简单使用

IK分词器包含两种模式：

• ik_smart：智能语义切分
• ik_max_word：最细粒度切分

首先我们来看看官方提供的标准分词方式

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}]
}

我们可以看到，他对中文的分词能力很差，一个字分一下，而对英文的java的分词效果很好。

我们再测试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分词器无法对这些词汇分词。
所以要想正确分词，IK分词器的词库也需要不断的更新，IK分词器提供了扩展词汇的功能。
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

此外我们还可以添加断分词的字段，同样是在IKAnalyzer.cfg.xml里配置，注意在线安装的话没有config目录，但是也不要手动创建config目录，具体解决方法可以在网上搜索。

索引库操作

Mapping映射属性

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

• type：字段数据类型，常见的简单类型有：
  • 字符串：text（可分词的文本）、keyword（精确值，例如：品牌、国家、ip地址）
  • 数值：long、integer、short、byte、double、float、
  • 布尔：boolean
  • 日期：date
  • 对象：object
• index：是否创建索引，默认为true
• analyzer：使用哪种分词器
• properties：该字段的子字段

索引库的CRUD

创建索引库与映射

基本语法：

• 请求方式：PUT
• 请求路径：/索引库名，可以自定义
• 请求参数：mapping映射

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

例子

## 创建索引库并且设置mapping映射
PUT /heima
{"mappings": {"properties": {"info":{"type": "text","analyzer": "ik_smart"  // 分词其类型},"age":{"type": "byte"},"email":{"type": "keyword","index": false  // 不创建索引},"name":{"type": "object","properties": {"fistName":{"type": "keyword"   },"lastName":{"type": "keyword"}}}}}
}

查询索引库

基本语法：

• 请求方式：GET
• 请求路径：/索引库名
• 请求参数：无

GET /索引库名

修改索引库

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

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

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

删除索引库

语法：

• 请求方式：DELETE
• 请求路径：/索引库名
• 请求参数：无

DELETE /索引库名

文档操作

新增文档

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

查询文档

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

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

删除文档

就不用多说了肯定是delete

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

修改文档

修改文档由两种方式：

• 全量修改：直接覆盖原来的文档
• 局部修改：根据提供的字段进行修改

全量修改

全量修改的方法和新增文档的方法一样
全量修改是覆盖原来的文档，其本质是两步操作：

• 根据指定的id删除文档
• 新增一个相同id的文档

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

这时候如果写了一个不存在的id那么就是新增

局部修改

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

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

批处理

批量处理的代码如下

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"} }

RestAPI

在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")
));

@Configuration
public class ElasticClient {@Bean(destroyMethod = "close")@ConditionalOnMissingBeanpublic RestHighLevelClient restHighLevelClient() {return new RestHighLevelClient(RestClient.builder(new HttpHost("192.168.200.200",9200,"http")));}}

创建索引库

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"}}}
}

创建索引

创建索引的API如下

代码分为三步：

• 1）创建Request对象。
  • 因为是创建索引库的操作，因此Request是CreateIndexRequest。
• 2）添加请求参数
  • 其实就是Json格式的Mapping映射参数。因为json字符串很长，这里是定义了静态字符串常量MAPPING_TEMPLATE，让代码看起来更加优雅。
• 3）发送请求
  • client.indices()方法的返回值是IndicesClient类型，封装了所有与索引库操作有关的方法。例如创建索引、删除索引、判断索引是否存在等

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

删除索引库

不用多说对象为DeleteIndexRequest

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

判断索引库是否存在

不用多说对象为GetIndexRequest

@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 ? "索引库已经存在！" : "索引库不存在！");
}

RestClient文档操作

新增文档

新增文档的API如下

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

可以看到与索引库操作的API非常类似，同样是三步走：

• 1）创建Request对象，这里是IndexRequest，因为添加文档就是创建倒排索引的过程
• 2）准备请求参数，本例中就是Json文档
• 3）发送请求

变化的地方在于，这里直接使用client.xxx()的API，不再需要client.indices()了。

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

查询文档

查询的请求语句如下：

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

与之前的流程类似，代码大概分2步：

• 创建Request对象
• 准备请求参数，这里是无参，直接省略
• 发送请求

可以看到，响应结果是一个JSON，其中文档放在一个_source属性中，因此解析就是拿到_source，反序列化为Java对象即可。

其它代码与之前类似，流程如下：

• 1）准备Request对象。这次是查询，所以是GetRequest
• 2）发送请求，得到结果。因为是查询，这里调用client.get()方法
• 3）解析结果，就是对JSON做反序列化

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

删除文档

删除的请求语句如下：

DELETE /hotel/_doc/{id}

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

• 1）准备Request对象，因为是删除，这次是DeleteRequest对象。要指定索引库名和id
• 2）准备参数，无参，直接省略
• 3）发送请求。因为是删除，所以是client.delete()方法

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

修改文档

我们上面说修改文档由两种方法，但是第一种方法我们肯定是不推荐的，因此这里直接看第二种方法

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

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

批量导入文档

在之前的案例中，我们都是操作单个文档。而数据库中的商品数据实际会达到数十万条，某些项目中可能达到数百万条。
我们如果要将这些数据导入索引库，肯定不能逐条导入，而是采用批处理方案。常见的方案有：

• 利用Logstash批量导入
  • 需要安装Logstash
  • 对数据的再加工能力较弱
  • 无需编码，但要学习编写Logstash导入配置
• 利用JavaAPI批量导入
  • 需要编码，但基于JavaAPI，学习成本低
  • 更加灵活，可以任意对数据做再加工处理后写入索引库

语法说明

批处理与前面讲的文档的CRUD步骤基本一致：

• 创建Request，但这次用的是BulkRequest
• 准备请求参数
• 发送请求，这次要用到client.bulk()方法

BulkRequest本身其实并没有请求参数，其本质就是将多个普通的CRUD请求组合在一起发送。例如：

• 批量新增文档，就是给每个文档创建一个IndexRequest请求，然后封装到BulkRequest中，一起发出。
• 批量删除，就是创建N个DeleteRequest请求，然后封装到BulkRequest，一起发出

可以看到，能添加的请求有：

• IndexRequest，也就是新增
• UpdateRequest，也就是修改
• DeleteRequest，也就是删除

示例

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