最详细【Elasticsearch】Elasticsearch Java API + Spring Boot集成 实战入门（基础篇）

许苑向上2024-11-06 13:37

Elasticsearch Java API + Spring Boot集成 实战入门（基础篇）

Spring Boot集成Elasticsearch 高级篇 后续更新 请关注 个人主页

一、初始Elasticseach

1、什么是Elasticseach

Elasticseach是一款非常强大的开源搜索引擎，可以帮助我们从海量数据中快速找到需要的内容。结合 kibana 、 Logstash 、 Beats ，也就是 elastic stack （ ELK ）。被广泛应用在日志数据分析、实时监控等领域。

2、Elasticsearch生态

Elasticsearch 生态系统非常丰富，包含了一系列工具和功能，帮助用户处理、分析和可视化数据，Elastic Stack 是其核心组成部分。

Elastic Stack（也称为 ELK Stack）由以下几部分组成：

  • Elasticsearch：核心搜索引擎，负责存储、索引和搜索数据。
  • Kibana：可视化平台，用于查询、分析和展示 Elasticsearch 中的数据。
  • Logstash：数据处理管道，负责数据收集、过滤、增强和传输到 Elasticsearch。
  • Beats：轻量级的数据传输工具，收集和发送数据到 Logstash 或 Elasticsearch。

Kibana 是 Elastic Stack 的可视化组件，允许用户通过图表、地图和仪表盘来展示存储在 Elasticsearch 中的数据。它提供了简单的查询接口、数据分析和实时监控功能

2、Elasticsearch结构

Elasticsearch采用倒排索引 ，相比mysql的正向索引提高了查询效率。

倒排索引过程：

  1. 首先进行分词得到词条。
  2. 倒排根据词条列表查找id查询文档。
  3. 最后存放结果集。

正向和倒排索引的区别：

正向是根据文档找词条，倒排是根据词条找文档。

3、Elasticsearch核心概念

  • 索引（Index）：类似于数据库中的表。

  • 文档（Document）：索引中的每条记录，类似于数据库中的行数据。文档以JSON格式存储。

  • 字段（Field）：文档中的每个键值对，类似于数据库中的列

  • 映射 （Mapping）：用于定义文档字段的数据类型以及其处理方式，类似于表结构。

  • 集群（Cluster）：多个节点组成的群集，用于存储数据并提供搜索功能。集群中的每个节点都可以处理数据。

  • 分片（Shard）：为了实现横向扩展，ES 将索引拆分成多个分片，每个分片可以分布在不同节点上。

  • 副本（Replica）：分片的复制品，用于提高可用性和容错性。

    和数据库类比：

    Elasticsearch 概念 关系型数据库类比
    Index Table
    Document Row
    Field Column
    Mapping Schema
    Shard Partition
    Replica Backup

4、Elasticsearch 实现全文检索的原理

  1. 分词
  2. 倒排索引（根据分词去词表查询文档Id，然后再根据文档Id去查询文档）

二、Elasticsearch入门

1、入门-环境安装准备

官方网址

1）安装 Elasticsearch

Elasticsearch 更新迭代非常快，所以安装时，一定要注意慎重选择版本号！

由于我们自己的项目用的 Spring Boot 2.x 版本，对应的 Spring Data Elasticsearch 客户端版本是 4.x，支持的 Elasticsearch 是 7.x，所以建议 Elasticsearch 使用 7.x 的版本。

个人中使用的是 7.17 版本，这是 7.x 系列的最后一个版本，包含了该系列所有的 bug 修复和改进，被广泛认为是最稳定的。

💡 可以在 官方文档 了解到版本兼容情况：比如 Spring 6 才支持 Elasticsearch 8.x

如果官网下不动，

Elasticsearch 7.8.0下载页面

参考官方文档

Windows 解压安装

其他操作系统安装

已经下载好的 提取码：52jl

注意，安装路径不要包含中文！

Windows 版的 Elasticsearch 压缩包，解压即安装完毕，解压后的 Elasticsearch 的目录结构如下 ：

目录 含义
bin 可执行脚本目录
config 配置目录
jdk 内置 JDK 目录
lib 类库
logs 日志目录
modules 模块目录
plugins 插件目录

安装完成后进入 es 的bin目录通过cmd打开命令窗口并执行启动命令：

elasticsearch.bat

可以用 CURL 测试是否启动成功：

curl -X GET "localhost:9200/?pretty"

正常输出如图：

在 Windows 系统上，你还可以选择是否安装为服务，方便启动和管理。

elasticsearch-service.bat

Usage: elasticsearch-service.bat install|remove|start|stop|manager [SERVICE_ID]

2）安装 Kibana

注意，只要是同一套技术，所有版本必须一致！此处都用 7.17 版本！

参考官方文档

安装 Kibana：https://www.elastic.co/guide/en/kibana/7.17/install.html

安装完成后进入 kibana 的bin目录cmd打开命令行窗口并执行启动命令：

kibana.bat

可以访问 http://localhost:5601/，即可开始使用。如图所示：![在这里插入图片描述](https://i-blog.csdnimg.cn/direct/65d5f100949b480ea46eddb8b5e0424f.png)

但 kibana 默认是英文，不变阅读，可以修改 config/kibana.yml 中的国际化配置：

然后重启 kibana 即可

注意，目前 Kibana 面板没有增加权限校验，所有人都能访问，所以请勿在线上直接部署！

3）测试

尝试利用 Kibana 的开发工具来操作 Elasticsearch 的数据，比如查询：

验证下分词器的效果，比如使用标准分词器：

POST /_analyze

{

"analyzer": "standard",

"text": "我是许苑，I love someone"

}

效果如图，英文被识别为了一个词，但中文未被识别：

默认支持的分词器如下：

  • standard：标准分词器。
  • simple：简单分词器。
  • whitespace：按空格分词。
  • stop：带停用词的分词器。
  • keyword：不分词，将整个字段作为一个词条。
  • pattern：基于正则表达式的分词器。
  • ngram 和 edge_ngram：n-gram 分词器。
    由于这些分词器都不支持中文，所以需要安装 IK 中文分词器，以满足我们的业务需要。

4）安装 IK 中文分词器（ES 插件）

开源地址

直接按照官方指引安装即可，注意下载和我们 Elasticsearch 一致的版本，可以在这里找到各版本的插件包：https://release.infinilabs.com/analysis-ik/stable/

在 ES 安装bin目录下执行：

elasticsearch-plugin.bat install https://release.infinilabs.com/analysis-ik/stable/elasticsearch-analysis-ik-7.17.23.zip

安装成功，需要重启 ES：

IK 分词器插件为我们提供了两个分词器：ik_smart 和 ik_max_word。

ik_smart 是智能分词，尽量选择最像一个词的拆分方式，比如"某人"会被识别为一个词

ik_max_word 尽可能地分词，可以包括组合词，比如"好学生"会被识别为 3 个词：好学生、好学、学生

POST /_analyze

{

"analyzer": "standard",

"text": "许苑爱上了某人"

}

2、实战入门

2.1、kibana控制台操作

1、索引库的操作
1）mapping 属性

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

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

2）创建索引库

ES 中通过 Restful 请求操作索引库、文档。请求内容用 DSL 语句来表示，

创建索引库和 mapping 的 DSL 语法如下：

json 复制代码 
PUT /索引库名称
{
  "mappings": {
    "properties": {
      " 字段名 ": {
        "type": "text",
        "analyzer": "ik_smart"
      },
      " 字段名 2": {
        "type": "keyword",
        "index": "false"
      },
      " 字段名 3": {
        "properties": {
          " 子字段 ": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

举例：

json 复制代码 
PUT /xuyuan
{
  "mappings": {
    "properties": {
      "info":{
        "type": "text",
        "analyzer": "ik_smart"
      },
      "email":{
        "type": "keyword",
        "index": "false"
      },
      "name":{
        "properties": {
          "firstName": {
            "type": "keyword"
          }
        }
      }
    }
  }
}

返回结果：

json 复制代码 
{
  "acknowledged": true,
  "shards_acknowledged": true,
  "index": "xuyuan"
}

3）查看索引库

GET /xuyuan

4）删除索引库

DELETE /xuyuan

5）修改索引库

索引库和 mapping 一旦创建无法修改 ，但是可以添加 新的字段，语法如下：

添加字段： PUT / 索引库名 /_mapping

json 复制代码 
PUT /xuyuan/_mapping
{
  "properties": {
    "age": {
      "type": "integer"
    }
  }
}

2、文档操作

1）新增文档

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

举例：

json 复制代码 
POST /xuyuan/_doc/2
{
  "info": "Java工程师",
  "email": "2517115657@qq.com",
  "age": 20,
  "name": {
    "firstName": "许苑",
    "fullName": "xuyuan"
  }
}

返回结果：

json 复制代码 
{
  "_index": "xuyuan",
  "_id": "2",
  "_version": 1,
  "result": "created",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 3,
  "_primary_term": 1
}

2）查看文档

GET /索引库名/_doc/文档 id

GET /xuyuan/_doc/2

返回结果：

json 复制代码 
{
  "_index": "xuyuan",
  "_id": "2",
  "_version": 1,
  "_seq_no": 3,
  "_primary_term": 1,
  "found": true,
  "_source": {
    "info": "Java工程师",
    "email": "2517115657@qq.com",
    "age": 20,
    "name": {
      "firstName": "许苑",
      "fullName": "xuyuan"
    }
  }
}

3）删除文档

DELETE /索引库名/_doc/文档 id

DELETE /xuyuan/_doc/2

返回结果：

json 复制代码 
{
  "_index": "xuyuan",
  "_id": "2",
  "_version": 2,
  "result": "deleted",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 4,
  "_primary_term": 1
}

4）修改文档

方式一：全量修改，会删除旧文档，添加新文档

json 复制代码 
PUT /xuyuan/_doc/1
{
  "info": "Java",
  "email": "2517115657@qq.com",
  "name": {
    "firstName": "oj",
    "fullName": "xy"
  }
}

返回结果：

json 复制代码 
{
  "_index": "xuyuan",
  "_id": "1",
  "_version": 7,
  "result": "updated",
  "_shards": {
    "total": 2,
    "successful": 1,
    "failed": 0
  },
  "_seq_no": 8,
  "_primary_term": 1
}

方式二：增量修改，修改指定字段值

json 复制代码 
POST /xuyuan/_update/1
{
  "doc": {
    "email": "github.com/xuyuan-upward"
  }
}

5）DSL 查询文档
（1）DSL 查询语法分类
常见的查询类型包括：

  • 查询所有：查询出所有数据，一般测试用。例如： match_all
  • 全文检索（ full text ）查询：利用分词器对用户输入内容分词，然后去倒排索引库中匹配。例如：
    • match_query
    • multi_match_query
  • 精确查询：根据精确词条值查找数据，一般是查找 keyword 、数值、日期、 boolean 等类型字段。例如：
    • ids
    • range
    • term
  • 地理（ geo ）查询：根据经纬度查询。例如：
    • geo_distance
    • geo_bounding_box
  • 复合（ compound ）查询：复合查询可以将上述各种查询条件组合起来，合并查询条件。例如：
    • bool
    • function_score

（2）DSL Query 基本语法

json 复制代码 
GET /indexName/_search
{
  "query": {
    " 查询类型 ": {
      " 查询条件 ": " 条件值 "
    }
  }
}

（3）查询所有

json 复制代码 
GET /hotel/_search
{
  "query": {
    "match_all": {}
  }
}

（4）全文检索查询

全文检索查询，会对用户输入内容分词，常用于搜索框搜索：

match查询，根据一个字段查询。

json 复制代码 
GET /hotel/_search
{
  "query": {
    "match": {
      "city": "杭州"
    }
  }
}

multi_match查询，根据多个字段查询，参与查询字段越多，查询性能越差。

json 复制代码 
GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "园",
      // 表示查询多个字段
      "fields": [
        "star_name",
        "name"
      ]
    }
  }
}

query：你要查询的文本内容。
fields：一个数组，指定你要在其上执行查询的字段。如果你只指定一个字段，则它行为类似于 match 查询。

（5）精确查询

精确查询一般是查找 keyword 、数值、日期、 boolean 等类型字段。所以不会对搜索条件分词。常见的有：

  • term ：根据词条精确值查询，根据词条精确匹配，一般搜索 keyword 类型、数值类型、布尔类型、日期类型字段。
json 复制代码 
GET /hotel/_search
{
  "query": {
    "term": {
      "city": "上海"
    }
  }
}
  • range ：根据值的范围查询
json 复制代码 
GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 70,
        "lte": 80
      }
    }
  }
}

6）地理查询

根据经纬度查询。常见的使用场景包括：

  • 滴滴：搜索我附近的出租车
  • 微信：搜索我附近的人
  • 位置共享。
json 复制代码 
GET /hotel/_search
{
  "query": {
  // 经度类型
    "geo_bounding_box": {
      "location": {
        "top_left": {
          "lat": 24,
          "lon": 35
        },
        "bottom_right": {
          "lat": 22,
          "lon": 33
        }
      }
    }
  }
}

（7）复合查询（bool function_score->重新算分
）

相关性算分

当我们利用match查询时候，文档结果会根据与搜索词条的关联度打分（_score），返回结果是按照分值降序排列。

相关打分算法，如下图所示：

算分函数查询，可以控制文档相关性算分，控制文档排名。

  • 过滤条件：哪些文档要加分
  • 算分函数：如何计算 function score（用于对某个字段或者多个字段重新计算得分）
  • 加权方式： function score 与 query score 如何运算
json 复制代码 
GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "all": " 外滩 "
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "id": "1"
            }
          },
          "weight": 10
        }
      ],
      "boost_mode": "multiply"
    }
  }
}

bool 查询

布尔查询是一个或多个查询子句的组合。子查询的组合方式有：

  • must ：必须匹配每个子查询，类似"与"
  • should ：选择性匹配子查询，类似"或"
  • must_not ：必须不匹配，不参与算分，类似"非",不参与算分尽量加上去，可以提高查询效率
  • filter ：必须匹配，不参与算分
    搜索品牌包含"如家"，价格不高于400 ，在坐标 23.21,33.5 周围 1000km范围内的酒店。
json 复制代码 
GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "brand": "如家"
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "price": {
              "gt": 400
            }
          }
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "1000km",
            "location": {
              "lat": 23.21,
              "lon": 33.5
            }
          }
        }
      ]
    }
  }
}

搜索结果的处理

（1）排序

默认Elasticsearch是支持对结果进行排序的，默认是根据相关度的算分（ _score ）来排序。可以排序字段类型有： keyword类型、数值类型、地理坐标类型、日期类型等。

json 复制代码 
GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": "desc" // 排序字段和排序方式 ASC 、 DESC
    }
    ]
}

2）分页

elasticsearch 默认情况下只返回 top10 的数据。而如果要查询更多数据就需要修改分页参数了。

elasticsearch 中通过修改 from 、 size 参数来控制要返回的分页结果：

json 复制代码 
GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0, // 分页开始的位置，默认为0
  "size": 10, // 期望获取的文档总数
  "sort": [
    {"price": "asc"}
    ]
}

3）深度分页问题

ES 是分布式的，所以会面临深度分页问题。例如按 price 排序后，获取 from = 990 ， size =10 的数据：

聚合所有结果，重新排序选取前 1000 个。

首先在每个数据分片上都排序并查询前1000 条文档。

然后将所有节点的结果聚合，在内存中重新排序选出前 1000 条文档。

最后从这 1000 条中，选取从 990 开始的10 条文档。

如果搜索页数过深，或者结果集（ from +size ）越大，对内存和 CPU 的消耗也越高。因此 ES 设定结果集查询的上限是 10000。

针对深度分页， ES 提供了一种较好解决方案，官方文档：

• search after ：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式。

（4）高亮

高亮：就是在搜索结果中把搜索关键字突出显示。

原理是这样的：

将搜索结果中的关键字用标签标记出来

在页面中给标签添加 css 样式

json 复制代码 
GET /hotel/_search
{
  "query": {
    "term": {
      "city": {
        "value": "杭州"
      }
    }
  },
  "highlight": {
    "fields": {
      "city": {
        "pre_tags": "<em>",
        "post_tags": "<em>"
      }
    }
  }
}

返回结果以高亮形式返回：

json 复制代码 
{
  "took": 0,
  "timed_out": false,
  "_shards": {
    "total": 1,
    "successful": 1,
    "skipped": 0,
    "failed": 0
  },
  "hits": {
    "total": {
      "value": 1,
      "relation": "eq"
    },
    "max_score": 1.23585,
    "hits": [
      {
        "_index": "hotel",
        "_id": "1",
        "_score": 1.611585,
        "_source": {
          "name": "许苑",
          "email": "z.cn",
          "price": 12,
          "score": 12,
          "brand": "汉庭",
          "city": "杭州",
          "star_name": "五星",
          "business": "虹桥",
          "location": "23.423424, 34.32131",
          "pic": "/1/2/3"
        },
        "highlight": {
          "city": [
            "<em>杭州<em>"
          ]
        }
      }
    ]
  }
}

2.2、RestClient -- Java API操作

什么是 RestClient

ES 官方提供了各种不同语言的客户端，用来操作 ES 。这些客户端的本质就是组装 DSL 语句，通过 http 请求发送给ES 。官方文档地址： https://www.elastic.co/guide/en/elasticsearch/client/index.html

利用 JavaRestClient 实现创建、删除索引库，判断索引库是否存在。

1、RestClient 操作索引库（Mapping）
1）分析数据结构

mapping 要考虑的问题：

字段名、数据类型、是否参与搜索、是否分词、如果分词，分词器是什么？

将数据导入数据，与此同时实现mysql同步到es

sql 复制代码 
create table tb_hotel (
    id bigint(20) not null comment '酒店id',
    name varchar(255) NOT NULL comment '酒店名称；例：7天酒店',
    address varchar(255) NOT NULL comment ' 酒店地址；例：航头路 ',
    price int(10) NOT NULL COMMENT ' 酒店价格；例： 329',
    score int(2) NOT NULL COMMENT ' 酒店评分；例： 45 ，就是 4.5 分 ',
    brand varchar(32) NOT NULL COMMENT ' 酒店品牌；例：如家 ',
    city varchar(32) NOT NULL COMMENT ' 所在城市；例：上海 ',
    star_name varchar(16) DEFAULT NULL COMMENT ' 酒店星级，从低到高分别是：1 星到 5 星， 1 钻到 5 钻 ',
    business varchar(255) DEFAULT NULL COMMENT ' 商圈；例：虹桥 ',
    latitude varchar(32) NOT NULL COMMENT ' 纬度；例： 31.2497',
    longitude varchar(32) NOT NULL COMMENT ' 经度；例： 120.3925',
    pic varchar(255) DEFAULT NULL COMMENT ' 酒店图片；例 :/img/1.jpg',
    PRIMARY KEY (id)
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;

酒店索引：

json 复制代码 
PUT /hotel
{
  "mappings": {
    "properties": {
      "id":{
        "type": "keyword"
      },
      "name":{
        "type": "text",
        "analyzer": "ik_max_word"
      },
      "address":{
        "type": "keyword",
        "index": false
      },
      "price":{
        "type": "integer"
      },
      "score":{
        "type": "integer"
      },
      "brand":{
        "type": "keyword"
      },
      "city":{
        "type": "keyword"
      },
      "star_name":{
        "type": "keyword"
      },
      "business":{
        "type": "keyword"
      },
      "location":{
        "type": "geo_point"
      },
      "pic":{
        "type": "keyword",
        "index": false
      }
    }
  }
}

2）初始化 JavaRestClient

引入依赖

<dependency>
  <groupId>org.elasticsearch.client</groupId>
    <artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>

初始化RestHighLevelClient

java 复制代码 
RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://192.168.150.101:9200")
 ));

3）创建索引库

java 复制代码 
private 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" +
            "      \"address\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"index\": false\n" +
            "      },\n" +
            "      \"price\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"score\":{\n" +
            "        \"type\": \"integer\"\n" +
            "      },\n" +
            "      \"brand\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"city\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"star_name\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"business\":{\n" +
            "        \"type\": \"keyword\"\n" +
            "      },\n" +
            "      \"location\":{\n" +
            "        \"type\": \"geo_point\"\n" +
            "      },\n" +
            "      \"pic\":{\n" +
            "        \"type\": \"keyword\",\n" +
            "        \"index\": false\n" +
            "      }\n" +
            "    }\n" +
            "  }\n" +
            "}";
    @Test
    public void testCreateHotelIndex() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://localhost:9200")
        ));
        // 1.创建 Request 对象
        CreateIndexRequest request = new CreateIndexRequest("hotel");
        // 2.请求参数， MAPPING_TEMPLATE是静态常量字符串，内容是创建索引库的 DSL语句
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
        // 3.发起请求
        CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);
        System.out.println(response);
    }

4）删除索引库

java 复制代码 
@Test
    public void testDeleteHotelIndex() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://localhost:9200")
        ));
        // 1.创建 Request对象
        DeleteIndexRequest request = new DeleteIndexRequest("hotel");
        // 2.发起请求
        AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
        System.out.println(delete);
    }

5）判断索引库是否存在

java 复制代码 
@Test
    public void testExistsHotelIndex() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://localhost:9200")
        ));
        // 1.创建 Request对象
        GetIndexRequest request = new GetIndexRequest("hotel");
        // 2.发起请求
        boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
        // 3.输出
        System.out.println(exists);
    }

2、RestClient 操作文档
1）添加酒店数据到索引库

java 复制代码 
@Test
    public void testIndexDocument() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://localhost:9200")
        ));
        String source= "{\n" +
                "  \"name\": \"xuyuan\",\n" +
                "  \"email\": \"2517115657@qq.com\"\n" +
                "}";
        // 1.创建 request对象
        IndexRequest request = new IndexRequest("hotel").id("1");
        // 2.准备 JSON文档
        request.source(source, XContentType.JSON);
        // 3.发送请求
        IndexResponse response = client.index(request, RequestOptions.DEFAULT);
        System.out.println(response);
        client.close();
    }

2）根据 id 查询酒店数据

java 复制代码 
@Test
    public void testGetDocumentById() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://localhost:9200")
        ));
        // 1.创建 request对象
        GetRequest request = new GetRequest("hotel", "1");
        // 2.发送请求，得到结果
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
        // 3.解析结果
        String json = response.getSourceAsString();
        System.out.println(json);
        client.close();
}

3）根据 id 修改酒店数据

修改文档数据有两种方式：

方式一：全量更新。再次写入 id 一样的文档，就会删除旧文档，添加新文档

方式二：局部更新。只更新部分字段，我们演示方式二

java 复制代码 
@Test
    public void testUpdateDocumentById() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://localhost:9200")
        ));
        // 1.创建 request对象
        UpdateRequest request = new UpdateRequest("hotel", "1");
        // 2.准备参数，每 2个参数为一对 key value
        request.doc(
                "email", "23212133@163.com"
        );
        // 3.更新文档
        client.update(request, RequestOptions.DEFAULT);
        client.close();
    }

4）根据 id 删除文档数据

java 复制代码 
 @Test
    public void testDeleteDocumentById() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://localhost:9200")
        ));
        // 1.创建 request对象
        DeleteRequest request = new DeleteRequest("hotel", "1");
        // 2.删除文档
        client.delete(request, RequestOptions.DEFAULT);
        client.close();
    }

2、RestClient 进行DSL文档查询
（1）查询所有

json 复制代码 
@Test
    public void testMatchAll() throws IOException {
        RestHighLevelClient client = new RestHighLevelClient(RestClient.builder(
                HttpHost.create("http://localhost:9200")
        ));
        try {
            // 1.准备 Request
            SearchRequest request = new SearchRequest("hotel");
            // 2.组织 DSL参数
            request.source().query(QueryBuilders.matchAllQuery());
            // 3.发送请求，得到响应结果
            SearchResponse response = client.search(request, RequestOptions.DEFAULT);
            //解析响应结果
            SearchHits searchHits = response.getHits();
            // 4.1.查询的总条数
            long total = searchHits.getTotalHits().value;
            // 4.2.查询的结果数组
            SearchHit[] hits = searchHits.getHits();
            for (SearchHit hit : hits) {
                // 4.3.得到 source
                String json = hit.getSourceAsString();
                System.out.println(json);
            }
        }finally {
            client.close();
        }

    }

（2）全文检索查询

全文检索的 match 和 multi_match 查询与 match_all 的 API 基本一致。差别是查询条件，也就是 query 的部分。

同样是利用 QueryBuilders 提供的方法：

json 复制代码 
//单字段查询
QueryBuilders.matchQuery("all", " 如家 ");
//多字段查询
QueryBuilders.multiMatchQuery(" 如家 ", "name", "business");

（3）精确查询

精确查询常见的有 term 查询和 range 查询，同样利用 QueryBuilders 实现：

json 复制代码 
//词条查询
QueryBuilders.termQuery("city", " 杭州 ");
//范围查询
QueryBuilders.rangeQuery("price").gte(100).lte(150);

（4）复合查询

精确查询常见的有 term 查询和 range 查询，同样利用 QueryBuilders 实现：

json 复制代码 
//创建布尔查询
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//添加 must条件
boolQuery.must(QueryBuilders.termQuery("city", " 杭州 "));
//添加 filter条件
boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250));
json 复制代码 
（5）排序和分页
//查询
request.source().query(QueryBuilders.matchAllQuery());
//分页
request.source().from(0).size(5);
//价格排序
request.source().sort("price", SortOrder.ASC);

（6）高亮

json 复制代码 
request.source().highlighter(new HighlightBuilder().field("name")
//是否需要与查询字段匹配
.requireFieldMatch(false));

3、Elasticsearch数据同步方案

（1）elasticsearch 与 mysql 之间的数据同步

  1. 方案一：基于中间队列的异步同步（异步通知）


消息队列Rabbitmq实现ES与MySQL数据同步方案 后续补上 请关注个人主页

  1. 方案二：监听binlog（Canal 阿里巴巴开源的一个项目，支持从MySQL的binlog获取变更并进行实时同步。

    CanalRabbitmq实现ES与MySQL数据同步方案 后续补上 请关注个人主页
  2. 方案三：基于定时全量同步（Batch Full Sync）定时全量同步实现ES与MySQL数据同步方案 后续补上
  3. 方案四（简单版）：通过Spring Boot的定时任务实现对过去一分钟更新的数据进行增量同步到ES。

4、集群

（1）ES 集群的分布式存储

当新增文档时，应该保存到不同分片，保证数据均衡，那么 coordinating node 如何确定数据该存储到哪个分片呢？

elasticsearch 会通过 hash 算法来计算文档应该存储到哪个分片：

说明：

shard = hash(_routing) % number_of_shards

_routing 默认是文档的 id

算法与分片数量有关，因此索引库一旦创建，分片数量不能修改！

（1）ES 集群的分布式查询

elasticsearch 的查询分成两个阶段：

scatter phase ：分散阶段， coordinating node 会把请求分发到每一个分片。

gather phase ：聚集阶段， coordinating node 汇总 data node 的搜索结果，并处理为最终结果集返回给用户。

相关推荐
qq_433099407 分钟前
Ubuntu20.04从零安装IsaacSim/IsaacLab
数据库
Dlwyz9 分钟前
redis-击穿、穿透、雪崩
数据库·redis·缓存
Theodore_10221 小时前
4 设计模式原则之接口隔离原则
java·开发语言·设计模式·java-ee·接口隔离原则·javaee
工业甲酰苯胺2 小时前
Redis性能优化的18招
数据库·redis·性能优化
冰帝海岸2 小时前
01-spring security认证笔记
java·笔记·spring
世间万物皆对象3 小时前
Spring Boot核心概念：日志管理
java·spring boot·单元测试
没书读了3 小时前
ssm框架-spring-spring声明式事务
java·数据库·spring
小二·3 小时前
java基础面试题笔记（基础篇）
java·笔记·python
开心工作室_kaic4 小时前
ssm161基于web的资源共享平台的共享与开发+jsp(论文+源码)_kaic
java·开发语言·前端
懒洋洋大魔王4 小时前
RocketMQ的使⽤
java·rocketmq·java-rocketmq
热门推荐
01(欧拉)openEuler系统添加网卡文件配置流程、(欧拉)openEuler系统手动配置ipv6地址流程、(欧拉)openEuler系统网络管理说明02PyTorch机器学习实现液态神经网络03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04玄机平台应急响应—webshell查杀05Coze扣子平台完整体验和实践（附国内和国际版对比）06Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO07【目标跟踪】相机运动补偿08Unity中PICO实现 隔空取物 和 接触抓取物体09RAG 实践- Ollama+RagFlow 部署本地知识库10怎样让音频速度变慢？请跟随以下方法进行操作