微服务day08

18 阅读 0 评论 0 点赞

Elasticsearch

需要安装elasticsearch和Kibana，应为Kibana中有一套控制台可以方便的进行操作。

安装elasticsearch

使用docker命令安装：

docker run -d \ 
  --name es \
  -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \  //设置他的运行内存空间，不要低于512否则出问题
  -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

安装Kibana

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

通过kibana向es发送Http请求。

倒排索引

小结：

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

线下安装：

首先，查看之前安装的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分词器上传至这个目录。

找到课前资料提供的ik分词器插件，课前资料提供了7.12.1版本的ik分词器压缩文件，你需要对其解压：

然后上传至虚拟机的/var/lib/docker/volumes/es-plugins/_data这个目录

重启es容器：

docker restart es

IK分词器包含两种模式：

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

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分词器提供了扩展词汇的功能。

1）打开IK分词器config目录：

注意，如果采用在线安装的通过，默认是没有config目录的，需要把课前资料提供的ik下的config上传至对应目录。

在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>

在IK分词器的config目录新建一个 ext.dic，可以参考config目录下复制一个配置文件进行修改：

传智播客
泰裤辣

重启elasticsearch

docker restart es

再次测试，可以发现传智播客和泰裤辣都正确分词了：

{
  "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文件添加拓展词典和停用词典
在词典中添加拓展词条或者停用词条

基础概念

索引库操作

Mapping映射属性

索引库操作

Restful规范

索引库操作

创建索引库：

基本语法：

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

格式：

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

实例代码

PUT /hmall
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": false
      },
      "name":{
        "properties": {
          "firstName":{
            "type":"keyword"
          },
          "lastName":{
            "type":"keyword"
          }
        }
      }
    }
  }
}

返回结果：

{
  "acknowledged" : true,
  "shards_acknowledged" : true,
  "index" : "hmall"
}

查询索引库

基本语法：

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

格式

GET /索引库名

实例代码

GET /hmall

查询结果：

{
  "hmall" : {
    "aliases" : { },
    "mappings" : {
      "properties" : {
        "email" : {
          "type" : "keyword",
          "index" : false
        },
        "info" : {
          "type" : "text",
          "analyzer" : "ik_smart"
        },
        "name" : {
          "properties" : {
            "firstName" : {
              "type" : "keyword"
            },
            "lastName" : {
              "type" : "keyword"
            }
          }
        }
      }
    },
    "settings" : {
      "index" : {
        "routing" : {
          "allocation" : {
            "include" : {
              "_tier_preference" : "data_content"
            }
          }
        },
        "number_of_shards" : "1",
        "provided_name" : "hmall",
        "creation_date" : "1731489076840",
        "number_of_replicas" : "1",
        "uuid" : "KJqNTGY9RhiqFHkliRdGcw",
        "version" : {
          "created" : "7120199"
        }
      }
    }
  }
}

修改索引库

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

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

语法说明：

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

添加字段：

PUT /hmall/_mapping
{
  "properties": {
    "age":{
      "type": "integer"
    }
  }
}

返回结果：

{
  "acknowledged" : true
}

删除索引库

语法：

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

语法格式

DELETE /索引库名

删除库

DELETE /hmall

执行结果

{
  "acknowledged" : true
}

索引库操作总结：

索引库操作有哪些？

创建索引库：PUT /索引库名
查询索引库：GET /索引库名
删除索引库：DELETE /索引库名
修改索引库，添加字段：PUT /索引库名/_mapping

可以看到，对索引库的操作基本遵循的Restful的风格，因此API接口非常统一，方便记忆。

文档操作

新增文档

语法规范

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

实例代码

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

运行结果

{
  "_index" : "hmall",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 8,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 8,
  "_primary_term" : 1
}

查询文档

语法规范

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

实例代码

GET /hmall/_doc/1

运行结果

{
  "_index" : "hmall",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 8,
  "_seq_no" : 8,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "info" : "黑马程序员Java讲师",
    "email" : "zy@itcast.cn",
    "name" : {
      "firstName" : "云",
      "lastName" : "赵"
    }
  }
}

删除文档

语法规范

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

实例代码

DELETE /hmall/_doc/1

运行结果

{
  "_index" : "hmall",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 9,
  "result" : "deleted",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 9,
  "_primary_term" : 1
}

修改文档

全量修改

语法规范

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

实例代码

#全量修改
PUT /hmall/_doc/1
{
  "info": "黑马程序员Python讲师",
    "email": "ls@itcast.cn",
    "name": {
        "firstName": "四",
        "lastName": "李"
    }
}

运行结果

第一次运行，由于前面已经删除了该文档所以执行类型为 created.

{
  "_index" : "hmall",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 10,
  "result" : "created",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 10,
  "_primary_term" : 1
}

第二次运行，为修改返回的类型为 updated。

{
  "_index" : "hmall",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 11,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 11,
  "_primary_term" : 1
}

部分修改

语法规范

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

实例代码

#局部修改
POST /hmall/_update/1
{
  "doc": {
    "email":"ZhaoYuen@itcast.com"
  }
}

运行结果

{
  "_index" : "hmall",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 12,
  "result" : "updated",
  "_shards" : {
    "total" : 2,
    "successful" : 1,
    "failed" : 0
  },
  "_seq_no" : 12,
  "_primary_term" : 1
}

当前文档的数据：

{
  "_index" : "hmall",
  "_type" : "_doc",
  "_id" : "1",
  "_version" : 12,
  "_seq_no" : 12,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "info" : "黑马程序员Python讲师",
    "email" : "ZhaoYuen@itcast.com",
    "name" : {
      "firstName" : "四",
      "lastName" : "李"
    }
  }
}

文档基础操作小结

文档批量处理

index代表新增操作
- _index：指定索引库名
- _id指定要操作的文档id
- { "field1" : "value1" }：则是要新增的文档内容
delete代表删除操作
- _index：指定索引库名
- _id指定要操作的文档id
update代表更新操作
- _index：指定索引库名
- _id指定要操作的文档id
- { "doc" : {"field2" : "value2"} }：要更新的文档字段

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



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

JavaRestClient

作用：向restful接口发送请求。

客户端初始化

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

4)创建一个测试用例来实现

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 java.io.IOException;

public class Test {
    private RestHighLevelClient client;
    //创建开始初始化函数，对客户端进行初始化

    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.21.101:9200")));
    }
    //测试代码
    @org.junit.jupiter.api.Test
    public void test(){
        System.out.println(client);
    }
    //测试用例结束后释放资源

    @AfterEach
    void tearDown() throws IOException {
        client.close();
    }
}

商品Mapping映射

分析那些字段需要添加到文档中。

根据分析编写的需求：

PUT /hmall
{
  "mappings": {
    "properties": {
      "id":{
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "price":{
        "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"
      }
    }
  }
}

索引库操作

创建索引库：

    //创建索引库
    @org.junit.jupiter.api.Test
    public void testCreateIndex() throws IOException {
        //创建Requst对象
        CreateIndexRequest request = new CreateIndexRequest("items");
        //准备参数 ,将编写的JSON字符串赋值给MAPPINF_JSON，XContentType.JSON用于指定是JSON格式
        request.source(MAPPINF_JSON, XContentType.JSON);
        //发送请求，RequestOptions.DEFAULT为是否有自定义配置，选择默认
        client.indices().create(request, RequestOptions.DEFAULT);
    }


    private final String MAPPINF_JSON = "{\n" +
            "  \"mappings\": {\n" +
            "    \"properties\": {\n" +
            "      \"id\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"name\":{\n" +
            "        \"type\": \"text\",\n" +
            "        \"analyzer\": \"ik_smart\"\n" +
            "      },\n" +
            "      \"price\":{\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" +
            "        \"index\": false\n" +
            "      },\n" +
            "      \"isAD\":{\n" +
            "        \"type\": \"boolean\"\n" +
            "      },\n" +
            "      \"updateTime\":{\n" +
            "        \"type\": \"date\"\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";

删除索引库

    //删除索引库
    @org.junit.jupiter.api.Test
    public void testDeleteIndex() throws IOException {
        //创建Requst对象
        DeleteIndexRequest request = new DeleteIndexRequest("items");
        //发送请求
        client.indices().delete(request,RequestOptions.DEFAULT);
    }

查看索引库

    //查找索引库
    @org.junit.jupiter.api.Test
    public void testGetIndex() throws IOException {
        //创建Requst对象
        GetIndexRequest request = new GetIndexRequest("items");
        //发送2请求
//        client.indices().get(request, RequestOptions.DEFAULT);
        //由于GEt请求返回的数据较多，如果只需要判断是否存在，则使用exists方法
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        System.out.println("exists = " + exists);
    }

文档操作

新增文档

由于索引库结构与数据库结构还存在一些差异，因此我们要定义一个索引库结构对应的实体。

package com.hmall.item.domain.po;

import io.swagger.annotations.ApiModel;
import io.swagger.annotations.ApiModelProperty;
import lombok.Data;

import java.time.LocalDateTime;

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

API语法

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

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

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

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

    //新增文档
    @org.junit.jupiter.api.Test
    public void test() throws IOException {
        //读取数据库获取商品信息
        Item item = service.getById(317578);
        //将商品信息对象转换为Dto
        ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);
        //将对象转换为JSON
        String jsonStr = JSONUtil.toJsonStr(itemDoc);

        //创建Requst对象
        IndexRequest request = new IndexRequest("items").id(itemDoc.getId());

        request.source(jsonStr, XContentType.JSON);

        //发送信息
        client.index(request, RequestOptions.DEFAULT);

    }

package com.hmall.item.es;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.json.JSONUtil;
import com.hmall.item.domain.dto.ItemDoc;
import com.hmall.item.domain.po.Item;
import com.hmall.item.service.impl.ItemServiceImpl;
import org.apache.http.HttpHost;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
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.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
import org.elasticsearch.common.xcontent.XContentType;
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 docTest {
    private RestHighLevelClient client;
    @Autowired
    private ItemServiceImpl service;
    //创建开始初始化函数，对客户端进行初始化

    @BeforeEach
    void setUp() {
        this.client = new RestHighLevelClient(RestClient.builder(HttpHost.create("http://192.168.21.101:9200")));
    }
    //新增文档,全局修改文档
    @org.junit.jupiter.api.Test
    public void test() throws IOException {
        //读取数据库获取商品信息
        Item item = service.getById(317578);
        //将商品信息对象转换为Dto
        ItemDoc itemDoc = BeanUtil.copyProperties(item, ItemDoc.class);
        //将对象转换为JSON
        String jsonStr = JSONUtil.toJsonStr(itemDoc);

        //创建Requst对象
        IndexRequest request = new IndexRequest("items").id(itemDoc.getId());

        request.source(jsonStr, XContentType.JSON);

        //发送信息
        client.index(request, RequestOptions.DEFAULT);

    }
    //查看文档
    @org.junit.jupiter.api.Test
    public void testGet() throws IOException {

        //创建Requst对象
        GetRequest request = new GetRequest("items","317578");

        //发送信息
        GetResponse response = client.get(request, RequestOptions.DEFAULT);

        String json = response.getSourceAsString();

        ItemDoc bean = JSONUtil.toBean(json, ItemDoc.class);
        System.out.println("bean = " + bean);

    }
    //删除文档
    @org.junit.jupiter.api.Test
    public void testdelect() throws IOException {

        //创建Requst对象
        DeleteRequest request = new DeleteRequest("items","317578");

        //发送信息
         client.delete(request, RequestOptions.DEFAULT);

    }

    //修改文档
    @org.junit.jupiter.api.Test
    public void testupdata2() throws IOException {

        //创建Requst对象
        UpdateRequest request = new UpdateRequest("items","317578");
        //数据都是独立的不是成对出现的
        request.doc(
                "price", 10000
        );

        //发送信息
        client.update(request, RequestOptions.DEFAULT);

    }


    //测试用例结束后释放资源
    @AfterEach
    void tearDown() throws IOException {
        client.close();
    }

}

批量操作文档

    //新增文档,全局修改文档
    @org.junit.jupiter.api.Test
    public void testBulk() throws IOException {
        //设置分页信息
        int size = 1000,pageNo = 1;
        //循环写入数据
        while (true){
            //读取数据库获取商品信息分页查询
            //设置当前查询条件，即状态为起售
            //创建分页对象
            Page<Item> page = service.lambdaQuery().eq(Item::getStatus, 1).page(new Page<Item>(pageNo, size));
            List<Item> records = page.getRecords();
            //判空
            if (records.isEmpty()||records == null){
                return;
            }
            //创建Requst对象
//            BulkRequest request = new BulkRequest();
//            for (Item item : records) {
//                request.add(new IndexRequest("items")
//                        .id(item.getId().toString())
//                        .source(JSONUtil.toJsonStr(BeanUtil.copyProperties(item, ItemDoc.class))),XContentType.JSON
//                );
//            }
            BulkRequest request = new BulkRequest("items");
            for (Item item : records) {
                // 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));
            }
            //发送信息
            client.bulk(request, RequestOptions.DEFAULT);
            pageNo++;
        }

    }

本站资源均来自互联网，仅供研究学习，禁止违法使用和商用，产生法律纠纷本站概不负责！如果侵犯了您的权益请与我们联系！

转载请注明出处：免费源码网-免费的源码资源网站 » 微服务day08

点赞(0) 打赏

本文分类：文章资讯
本文标签：微服务day08
浏览次数：18 次浏览
本文链接：https://freeymw.com/article/37021.html

上一篇 > AI助力智能运维！在Linux主机上实现和chatgpt对话
下一篇 > HTML&CSS：实现可爱的冰墩墩

评论列表共有 0 条评论

暂无评论

微服务day08

Elasticsearch

安装elasticsearch

安装Kibana

倒排索引

小结：

IK分词器

安装

总结

基础概念

索引库操作

Mapping映射属性

索引库操作

Restful规范

索引库操作

创建索引库：

查询索引库

修改索引库

删除索引库

索引库操作总结：

文档操作

新增文档

查询文档

删除文档

修改文档

全量修改

部分修改

文档基础操作小结

文档批量处理

JavaRestClient

客户端初始化

商品Mapping映射

索引库操作

创建索引库：

删除索引库

查看索引库

文档操作

新增文档

API语法

批量操作文档

评论列表 共有 0 条评论

发表评论 取消回复

评论列表共有 0 条评论

发表评论取消回复