ElasticSearch

最新推荐文章于 2020-11-02 00:49:56 发布
最新推荐文章于 2020-11-02 00:49:56 发布
阅读量404 收藏
点赞数
分类专栏： 2020谷粒商城
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lsswshxcg/article/details/108034042
版权

Elastic Search

简介

是什么

​ Elasticsearch是一个基于Apache Lucene™的开源搜索引擎。无论在开源还是专有领域，Lucene可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。

特点：

  • 分布式的实时文件存储，每个字段都被索引并可被搜索

  • 分布式的实时分析搜索引擎–做不规则查询

  • 可以扩展到上百台服务器，处理PB级结构化或非结构化数据

  • Elasticsearch也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。

架构

索引对应着关系型数据库的数据库，类型对应数据库的表，文档对应表里面的记录，属性对应着表里面的列名。

image-20200624222019531

ES能做什么？

  • 全文检索（全部字段）、模糊查询（搜索）、数据分析（提供分析语法，例如聚合）

网址

官网

官方文档

官方中文版本太低了不建议看

中文文档

基本概念

index（索引）

动词，相当于MySQL中的insert。

名词，相当于MySQL中的Database。

Type（类型）

在Index （索引）中， 可以定义一个或多个类型。类似于MySQL中的Table；每一种类型的数据放在一起。不建议使用type了官方已经说明不用了。

Document（文档）

保存在某个索引（Index）下，某种类型（Type） 的一个数据（Document），文档是JSON格式的，Document就像是MySQL中的某个Table里面的内容；

倒排索引机制

  • ES检索很快的原因：倒排索引。

  • 倒排索引，当我们插入文档时，es会先将我们插入的数据进行分词操作。然后存入倒排索引中。倒排索引表维护了每个单词在那个文档中。这就是我们查询快的原因。

  • 检索的时候，也是将检索的内容进行分词，分词会查询倒排索引表获取数据。然后根据相关系数得分对检索的结果进行排序（按照分数降序排列）。

image-20200624222815287

Docker 安装

elasticsearch ： 存储和检索数据

kibana ： 可视化检索数据

# 启动es
[vagrant@haitao-gmall ~]$ sudo chmod -R 777 /mydata && mkdir -p /mydata/elasticsearch/config && echo "http.host: 0.0.0.0" >/mydata/elasticsearch/config/elasticsearch.yml && docker network create --driver bridge es-network

# 9200 我们给es发送指令的端口。9300 es 集群的通信端口
[vagrant@haitao-gmall ~]$ docker rm -f elasticsearch && docker run -d -p 9200:9200 -p 9300:9300 \
-e  "discovery.type=single-node" \
-e ES_JAVA_OPTS="-Xms64m -Xmx512m" \
-v /mydata/elasticsearch/config/elasticsearch.yml:/usr/share/elasticsearch/config/elasticsearch.yml \
-v /mydata/elasticsearch/data:/usr/share/elasticsearch/data \
-v  /mydata/elasticsearch/plugins:/usr/share/elasticsearch/plugins \
--restart always \
--network es-network \
--name elasticsearch \
elasticsearch:7.6.2

# 启动kibana
[vagrant@haitao-gmall ~]$ docker rm -f kibana &&  docker run -d \
-p 5601:5601 \
-e ELASTICSEARCH_HOSTS=http://elasticsearch:9200 \
--restart always \
--name kibana \
--network es-network \
kibana:7.6.2

# 查看容器的运行日志
[vagrant@haitao-gmall ~]$ docker logs elasticsearch


# 注意 es 和 kibana 启动需要一点时间，所以一启动是访问不到的。

image-20200624155544042

image-20200624160208227

初步检索

_cat

GET/_ cat/nodes：查看所有节点
GET/_ cat/health： 查看es健康状况
GET/_ cat/master： 查看主节点
GET / cat/indices： 查看所有索引 show databases；

索引一个文档(保存)

保存一个数据，保存在哪个索引的哪个类型下，指定用那个唯一标识。
PUT customer/external/1 --》在customer索引下的external类型下保存1号数据为

PUT customer/external/1

PUT和POST都可以
POST新增。如果不指定id，会自动生成id。指定id就会修改这个数据，并新增版本号；
PUT可以新增也可以修改。PUT必须指定id；由于PUT需要指定id，我们一般用来做修改操作，不指定id会报错。

这些带有下划线开头的，称为元数据，反映了当前的基本信息。

"_index": "customer"  表明该数据在哪个数据库下；

"_type": "external"     表明该数据在哪个类型下；

"_id": "1"                    表明被保存数据的id；

 "_version": 1,            被保存数据的版本

"result": "created"      这里是创建了一条数据，如果重新put一条数据，则该状态会变为updated，并且版本号也会发生变化。

下面选用POST方式：

添加数据的时候，不指定ID，会自动的生成id，并且类型是新增：

再次使用POST插入数据，仍然是新增的：

添加数据的时候，指定ID，会使用该id，并且类型是新增：

再次使用POST插入数据，类型为updated

查询文档

GET /customer/external/1

http://192.168.137.14:9200/customer/external/1

{
    "_index": "customer",//在哪个索引
    "_type": "external",//在哪个类型
    "_id": "1",//记录id
    "_version": 3,//版本号
    "_seq_no": 6,//并发控制字段，每次更新都会+1，用来做乐观锁
    "_primary_term": 1,//同上，主分片重新分配，如重启，就会变化
    "found": true,
    "_source": {
        "name": "John Doe"
    }
}

乐观锁

PUT http://192.168.1.10:9200/customer/external/1?if_seq_no=4&if_primary_term=1

通过“if_seq_no=1&if_primary_term=1 ”，当序列号匹配的时候，才进行修改，否则不修改。

更新文档

  1. POST更新文档，带有_update
# 我们的文档内容必须放在doc 属性中。
{
   "doc":{
        "name":1
   }
}

# 更新之前会对比原来的数据，数据一致什么都不做，version、seq_no、primary_term 都不变

# 加了_update 就说明是修改，不能执行增加操作
  1. POST更新文档，不带_update
# put 和 posst（不带_update）都会直接更新数据

删除文档或索引

# 注：elasticsearch并没有提供删除类型的操作，只提供了删除索引和文档的操作。
DELETE customer/external/1
DELETE customer

bulk批量API

语法格式：

{action:{metadata}}\n
{request body  }\n

{action:{metadata}}\n
{request body  }\n

# 测试批量API 需要借助kibana 完成。
# 这里的批量操作，当发生某一条执行发生失败时，其他的数据仍然能够接着执行，也就是说彼此之间是独立的。
# bulk api以此按顺序执行所有的action（动作）。如果一个单个的动作因任何原因失败，它将继续处理它后面剩余的动作。当bulk api返回时，它将提供每个动作的状态（与发送的顺序相同），所以您可以检查是否一个指定的动作是否失败了。

image-20200624170705495

实例1: 执行多条数据

POST customer/external/_bulk
{"index":{"_id":"1"}}
{"name":"John Doe"}
{"index":{"_id":"2"}}
{"name":"John Doe"}

实例2：对于整个索引执行批量操作

POST /_bulk
{"delete":{"_index":"website","_type":"blog","_id":"123"}}
{"create":{"_index":"website","_type":"blog","_id":"123"}}
{"title":"my first blog post"}
{"index":{"_index":"website","_type":"blog"}}
{"title":"my second blog post"}
{"update":{"_index":"website","_type":"blog","_id":"123"}}
{"doc":{"title":"my updated blog post"}}

样本测试数据

准备了一份顾客银行账户信息的虚构的JSON文档样本。每个文档都有下列的schema（模式）。

{
	"account_number": 1,
	"balance": 39225,
	"firstname": "Amber",
	"lastname": "Duke",
	"age": 32,
	"gender": "M",
	"address": "880 Holmes Lane",
	"employer": "Pyrami",
	"email": "amberduke@pyrami.com",
	"city": "Brogan",
	"state": "IL"
}

测试数据

进阶检索

Search API

ES支持两种基本方式检索；

  • 通过REST request uri 发送搜索参数 （uri +检索参数）；
  • 通过REST request body 来发送它们（uri+请求体）；
检索信息

  • 一切检索从 search开始

    GET bank/_ search检索bank下所有信息，包括type和docs
    GET bank/_ search?q=*&sort=account_ number:asc请求参数方式检索

    响应结果解释：

    took #  Elasticsearch执行搜索的时间（毫秒）
time_out #  告诉我们搜索是否超时
_shards # 告诉我们多少个分片被搜索了，以及统计了成功/失败的搜索分片
hits # 搜索结果
hits.total # 搜索结果
hits.hits # 实际的搜索结果数组（默认为前10的文档）
sort # 结果的排序key （键） （没有则按score排序）
score 和 max_score  # 相关性得分和最高得分（全文检索用）

  • url 加请求体检索

    # query 查询条件，sort 排序 ，from size 分页操作 ， _source指定查询的字段
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "balance": {
        "order": "desc"
      }
    }
  ],
  "from": 5,
  "size": 5,
  "_source": ["balance","firstname"]
}

Query DSL

基本语法

​ Elasticsearch提供了一个可以执行查询的Json风格的DSL （ domain specific language领域特定语言）。这个被称为Query DSL。该查询语言非常全面，并且刚开始的时候感觉有点复杂，真正学好它的方法是从一些基础的示例开始的。

  • 一个查询语句的典型结构
{
  query_name:{
    argument:value,
    argument:value,...
  }
}
  • 如果是针对某个字段，那么他的结构如下：
{
  query_name:{
    field_name:{
      argument:value,
    	argument:value,...
    }
  }
}
  • 常用的 argument
query 定义如何查询，
match_ all 查询类型【代表查询所有的所有】，es 中可以在query中组合非常多的查询类型完成复杂查询
除了query 参数之外，我们也可以传递其它的参数以改变查询结果。如 sort, sizefrom+size限定，完成分页功能
sort排序，多字段排序，会在前序字段相等时后续字段内部排序，否则以前序为准
返回部分

_source : 指定返回的属性是那些

# query 查询条件，sort 排序 ，from size 分页操作 ， _source指定查询的字段
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "balance": {
        "order": "desc"
      }
    }
  ],
  "from": 5,
  "size": 5,
  "_source": ["balance","firstname"]
}
match【匹配查询】
  • 基本类型（非字符串），精确匹配
# match 匹配查询， 基本类型(非字符串)，精确匹配
GET /bank/_search
{
  "query": {
    "match": {
      "account_number": "20"
    }
  }
}
  • 字符串，全文检索
# match 匹配查询， 字符串，全文检索
# 全文检索会按照评分进行排序，会对检索条件进行分词匹配
GET /bank/_search
{
  "query": {
    "match": {
      "address": "Kings"
    }
  }
}
match_phrase【短语匹配】

将需要匹配的值当成一个整体单词（不分词）进行检索。

GET /bank/_search
{
  "query": {
    "match_phrase": {
      "address": "mill lane"
    }
  }
}
multi_match【多字段匹配】

多字段之间是 or 的关系 ==> where address like mill or city like mill

GET /bank/_search
{
  "query": {
    "multi_match": {
      "query": "mill",
      "fields": [
        "address",
        "city"
      ]
    }
  }
}
bool【复合查询】

bool用来做复合查询：
复合语句可以合并任何其它查询语句，包括复合语句，了解这一点是很重要的。这就意味着，复合语句之间可以互相嵌套，可以表达非常复杂的逻辑。

bool 关系之间是 and 的关系,组合多查询

must 必须满足条件，must_no 必须不满足，should 应该满足的话分高一点，不满足也没关系

  • must：必须达到must列举的所有条件
GET /bank/_search
{
  "query": {
    "bool": {
      "must": [
        {"range": {
          "age": {
            "gte": 10,
            "lte": 20
          }
        }}
      ]
    }
  }
}
  • must_not 必须不是指定的情况
GET /bank/_search
{
  "query": {
    "bool": {
      "must_not": [
        {
          "match": {
            "age": "38"
          }
        }
      ]
    }
  }
}
  • should： 应该达到should列举的条件，如果达到会增加相关文档的评分，并不会改变查询的结果。如果query中只有should且只有一种匹配规则，那么should的条件就会被作为默认匹配条件而去改变查询结果
GET /bank/_search
{
  "query": {
    "bool": {
      "should": [
        {
          "match": {
            "lastname": "haitao"
          }
        }
      ]
    }
  }
}
filter【结果过滤】

  • 并不是所有的查询都需要产生分数，特别是那些仅用于“filtering" （过滤）的文档。为了不计算分数Elasticsearch会自动检查场景并且优化查询的执行。

  • filter,不会计算相关性得分，must_no 其实也是filter 也不会计算相关性得分。

GET /bank/_search
{"query": {
  "bool": {
    "filter": [
      {"range": {
        "age": {
          "gte": 10,
          "lte": 20
        }
      }}
    ]
  }
}}
事件猫述
must子句（查询）必须出现在匹配的文档中，并将有助于得分.
filter子句（查询）必须出现在匹配的文档中。然而不像must此查询的分数将被忽略。
should子句（查询）应出现在匹配文档中，在布尔查询中不包含 must或 fiter子句，一个或多个should子句必须有相匹配的文件。匹配should 条件的最小数且可通过设置minimum_should_match参数。
must_not子句（查询）不能出现在匹配的文档中。
term【精确匹配】

https://www.elastic.co/guide/en/elasticsearch/reference/current/query-dsl-term-query.html

image-20200625123951735

和match 一样。匹配某个属性的值。全文检索字段用match，其他非text字段匹配用term。

# term ，建议精确匹配使用term，全文检索使用match 之类的。
# 因为 term 不会对我们的检索条件分词，然后在匹配
# keyword 也可以达到term 的效果（精确匹配）
GET /bank/_search
{
  "query": {
    "term": {
      "address": "132 Gunnison"
    }
  }
}
GET /bank/_search
{
  "query": {
    "match": {
      "address.keyword": "132 Gunnison"

    }
  }
}

# 这个不算精确匹配，只要目标属性的值包含或者等于就能被检索到
GET /bank/_search
{
  "query": {
    "match_phrase": {
      "address": "132 Gunnison"

    }
  }
}
Aggregation【执行聚合】

​ 聚合提供了从数据中分组和提取数据的能力。最简单的聚合方法大致等于SQL GROUPBY和SQL聚合函数。在Elasticsearch中，您有执行搜索返回hits （命中结果），并且同时返回聚合结果，把一个响应中的所有hits （命中结果）分隔开的能力。这是非常强大且有效的，您可以执行查询和多个聚合，并且在一次使用中得到各自的（任何一个的）返回结果，使用一次简洁和简化的API来避免网络往返。

聚合文档

  • 聚合的语法

    aggs : 执行聚合

"aggs":{
  "aggs_name 这次聚合的名字，方便展示在结果集中":{
    "AGG_TYPE聚合的类型（avg，term，terms）":{}
  }
}
  • 搜索address中包含mill 的所有人的年龄分布以及平均年龄
GET /bank/_search
{
  "query": {
    "match": {
      "address": "mill"
    }
  },
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age"
      }
    },
    "ageAvg": {
      "avg": {
        "field": "age"
      }
    }
  },
  "size": 0
}
  • 按照年龄聚合，并且求出这些年龄段的这些人的平均工资
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAvg": {
      "terms": {
        "field": "age"
      },
      "aggs": {
        "balanceAvg": {
          "avg": {
            "field": "balance"
          }
        }
      }
    }
  }
}
  • 查出所有年龄的分布，并且这些年龄段中M的平均薪资和F的平均薪资以及这个年龄的总体平均工资
GET /bank/_search
{
  "query": {
    "match_all": {}
  },
  "aggs": {
    "ageAgg": {
      "terms": {
        "field": "age",
        "size": 100
      },
      "aggs": {
        "genderAgg": {
          "terms": {
            "field": "gender.keyword",
            "size": 100
          },
          "aggs": {
            "balanceAvg": {
              "avg": {
                "field": "balance"
              }
            }
          }
        },
        "ageBalanceAvg":{
          "avg": {
            "field": "balance"
          }
        }

      }
    }
  }

Mapping

字段类型

mapping的文档

mapping支持的数据类型

image-20200625130324697

image-20200625130338153

image-20200625130410106

image-20200625130429064

映射

Mapping （映射）
Mapping是用来定义一个文档（document），以及它所包含的属性（field） 是如何存储和索引的。比如，使用mapping来定义：

  • 哪些字符串属性应该被看做全文本属性（full text fields）
  • 哪些属性包含数字，日期或者地理位置。
  • 文档中的所有属性是否都能被索引（_all 配置）。
  • 日期的格式。
  • 自定义映射规则来执行动态添加属性。
  • 查看mapping信息
GET /bank/_mapping
  • 能自动猜测的映射类型
JSON Type域Type
布尔型：true、falseboolean
整数：123long
浮点数：123.35double
字符串，有效日期：2020-06-20date
字符串：foo barstring
新版本改动
介绍

ElasticSearch7 去掉type概念

  1. 关系型数据库中两个数据表示是独立的，即使他们里面有相同名称的列也不影响使用，但ES 中不是这样的。elasticsearch是基于Lucene开发的搜索引擎，而ES中不同type下名称相同 的filed最终在Lucene中的处理方式是一样的。

    • 两个不同type下的两个user_name，在ES同一个索引下其实被认为是同一个filed，你必 须在两个不同的type中定义相同的filed映射。否则，不同type中的相同字段名称就会在 处理中出现冲突的情况，导致Lucene处理效率下降。
    • 去掉type就是为了提高ES处理数据的效率。

  2. Elasticsearch 7.x

    • URL中的type参数为可选。比如，索引一个文档不再要求提供文档类型。

  3. Elasticsearch 8.x

    • 不再支持URL中的type参数。

  4. 解决：

    • 将索引从多类型迁移到单类型，每种类型文档一个独立索引
    • 将已存在的索引下的类型数据，全部迁移到指定位置即可。详见数据迁移
创建索引

创建索引的时候指定属性的类型，不使用类型推断

PUT /my_index
{
  "mappings": {
    "properties": {
      "age":{"type": "integer"},
      "email":{"type": "keyword"},
      "name":{"type": "text"}
    }
  }
}
添加新的映射信息
PUT /my_index/_mapping
{
  "properties":{
    "employee_id":{
      "type":"long",
      "index":false
    }
  }
}
添加映射

对于已经存在的映射字段，我们不能更新。更新必须创建新的索引进行数据迁移

数据迁移

  1. 创建新的索引，并且指定映射类型（也可以先创建索引，然后给索引添加类型映射）

  2. 进行数据迁移

    • 如果老的数据有type需要指定类型
    POST _reindex
{
  "source":{
    "index":"old_bank"
  },
  "dest":{
    "index":"new_bank"
  }
}

POST _reindex
{
  "source":{
    "index":"old_bank",
    "type":"customer"
  },
  "dest":{
    "index":"new_bank"
  }
}

PUT /new_bank
{
  "mappings": {
    "properties": {
      "account_number": {
        "type": "integer"
      },
      "address": {
        "type": "text",
        "fields": {
          "keyword": {
            "type": "keyword",
            "ignore_above": 256
          }
        }
      }
    }
  }
}

# 源索引有类型时需要指定类型
POST _reindex
{
  "source": {
    "index": "bank",
    "type": "account"
  }
  , "dest": {
    "index": "new_bank"
  }
}

# 没有类型就不指定type
POST _reindex
{
  "source": {
    "index": "bank"
  }
  , "dest": {
    "index": "new_bank"
  }
}

分词

一个tokenizer（分词器）接收一个字符流，将之分割为独立的tokens（词元，通常是独立的单词），然后输出tokens流。

例如：whitespace tokenizer遇到空白字符时分割文本。它会将文本“Quick brown fox!”分割为[Quick,brown,fox!]。

该tokenizer（分词器）还负责记录各个terms(词条)的顺序或position位置（用于phrase短语和word proximity词近邻查询），以及term（词条）所代表的原始word（单词）的start（起始）和end（结束）的character offsets（字符串偏移量）（用于高亮显示搜索的内容）。

elasticsearch提供了很多内置的分词器，可以用来构建custom analyzers（自定义分词器）。

分词器文档

安装ik分词器

我下载好的7.62

官方下载

安装方式

[vagrant@haitao-gmall plugins]$ mkdir ik
[vagrant@haitao-gmall plugins]$ cd ik/
[vagrant@haitao-gmall ik]$ unzip ../elasticsearch-analysis-ik-7.6.2.zip
[vagrant@haitao-gmall plugins]$ rm -rf elasticsearch-analysis-ik-7.6.2.zip

# 重启es，并查看es 控制台输出
[vagrant@haitao-gmall plugins]$ docker restart elasticsearch
elasticsearch
[vagrant@haitao-gmall plugins]$ docker logs elasticsearch

# 查看是否安装成功
[vagrant@haitao-gmall plugins]$ docker exec -it elasticsearch elasticsearch-plugin list

image-20200625133856774

image-20200625134538978

测试ik分词器

默认的分词器

ik分词器的使用

# 默认的分词器
POST _analyze
{
  "analyzer": "standard",
  "text": "尚硅谷电商项目"
}

# 使用ik分词器
GET _analyze
{
   "analyzer": "ik_smart",
   "text":"我是中国人"
}

# 使用ik分词器
GET _analyze
{
   "analyzer": "ik_max_word",
   "text":"我是中国人"
}

能够看出不同的分词器，分词有明显的区别，所以以后定义一个索引不能再使用默认的 mapping 了，要手工建立 mapping.因为要选择分词器。

自定义词库（扩展）
  • 修改/usr/share/elasticsearch/plugins/ik/config中的IKAnalyzer.cfg.xml
    /usr/share/elasticsearch/plugins/ik/config
<?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"></entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords"></entry>
	<!--用户可以在这里配置远程扩展字典 -->
	<entry key="remote_ext_dict">http://nginx/es/fenci.txt</entry> 
	<!--用户可以在这里配置远程扩展停止词字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

原来的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"></entry>
	 <!--用户可以在这里配置自己的扩展停止词字典-->
	<entry key="ext_stopwords"></entry>
	<!--用户可以在这里配置远程扩展字典 -->
	<!-- <entry key="remote_ext_dict">words_location</entry> -->
	<!--用户可以在这里配置远程扩展停止词字典-->
	<!-- <entry key="remote_ext_stopwords">words_location</entry> -->
</properties>

修改完成后，需要重启elasticsearch容器，否则修改不生效。

更新完成后，es只会对于新增的数据用更新分词。历史数据是不会重新分词的。如果想要历史数据重新分词，需要执行：

POST my_index/_update_by_query?conflicts=proceed

注意：扩展词典的地址我们是搭建nginx 来提供的静态资源，所以需要启动nginx（http://nginx/es/fenci.txt）。下面有启动步骤。

ElasticSearch-Rest-Client

介绍

9300: TCP
  • spring-data-elasticsearch:transport-api.jar;
    • springboot版本不同，ransport-api.jar不同，不能适配es版本
    • 7.x已经不建议使用，8以后就要废弃
9200: HTTP
  • jestClient: 非官方，更新慢；
  • RestTemplate：模拟HTTP请求，ES很多操作需要自己封装，麻烦；
  • HttpClient：同上；
  • Elasticsearch-Rest-Client：官方RestClient，封装了ES操作，API层次分明，上手简单；
  • 最终选择Elasticsearch-Rest-Client（elasticsearch-rest-high-level-client）；
    https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.6/java-rest-high.html

image-20200625163655451

search api

Index api

SpringBoot 整合

依赖

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

注意：SpringBoot 默认整合了不是我们对应版本的es，我们需要改一下

image-20200626221200999

配置

配置类编写API

请求设置项

/**
 * User: haitao
 * Date: 2020/6/25
 * <p>
 * 1.导入依赖
 * 2.编写配置
 * 3. 注入到IOC 中
 * 4. 参考API https://www.elastic.co/guide/en/elasticsearch/client/java-rest/7.6/java-rest-high.html
 */
@Configuration
public class GulimallElasticSearchConfig {
    // 
    public static final RequestOptions COMMON_OPTIONS;

    static {
        RequestOptions.Builder builder = RequestOptions.DEFAULT.toBuilder();
//    builder.addHeader("Authorization", "Bearer " + TOKEN);
//    builder.setHttpAsyncResponseConsumerFactory(
//        new HttpAsyncResponseConsumerFactory
//            .HeapBufferedResponseConsumerFactory(30 * 1024 * 1024 * 1024));
        COMMON_OPTIONS = builder.build();
    }

    @Bean
    public RestHighLevelClient restHighLevelClient() {
        RestHighLevelClient client = new RestHighLevelClient(
                RestClient.builder(
                        new HttpHost("192.168.1.10", 9200, "http")));
        return client;
    }
}

使用

使用api

我们的使用场景

image-20200626151530604

安装nginx

# 将nginx 默认的配置copy 出来
[vagrant@haitao-gmall-advance ~]$ docker run -d -P --name nginx nginx:1.10
[vagrant@haitao-gmall-advance ~]$ mkdir -p /mydata/nginx && docker cp nginx:/etc/nginx /mydata/nginx && mv /mydata/nginx/nginx /mydata/nginx/conf
[vagrant@haitao-gmall-advance ~]$ mkdir -p /mydata/nginx/html && docker cp nginx:/usr/share/nginx/html /mydata/nginx/html
[vagrant@haitao-gmall-advance ~]$ mkdir -p /mydata/nginx/html/es
[vagrant@haitao-gmall-advance ~]$ cat>/mydata/nginx/html/es/fenci.txt<<EOF
尚硅谷
乔碧萝
EOF
[vagrant@haitao-gmall-advance ~]$docker rm -f nginx
[vagrant@haitao-gmall-advance ~]$docker run -d -p 80:80 \
-v /mydata/nginx/html:/usr/share/nginx/html \
-v /mydata/nginx/logs:/var/log/nginx \
-v /mydata/nginx/conf:/etc/nginx \
--network es-network \
--restart always \
--name nginx \
nginx:1.10

# 默认生成的文件夹权限是root，所以这里改一下
[vagrant@haitao-gmall-advance ~]$sudo chmod -R 777 /mydata/
haitaoss
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
es-head Elasticsearch的可视化操作插件
12-19
es-head是一个针对Elasticsearch的可视化操作插件。它提供了一个便捷的操作工具，可以连接Elasticsearch搜索引擎，并提供可视化的操作页面，对Elasticsearch进行各种设置和数据检索功能的管理。 es-head 插件可以在...
elasticSearch(ES)最新版 ik分词插件7.10 elasticsearch-analysis-ik-7.10.0
11-20
Elasticsearch（ES）是一种流行的开源全文搜索引擎，它基于Lucene构建，提供了分布式、RESTful风格的搜索和分析引擎服务。在中文环境下，为了实现精确的分词和搜索，我们需要安装适合版本的分词插件，如“elastic...
全网最牛逼的 Elasticsearch 天团博客集合
铭毅天下Elasticsearch
10-09 5202
1、事出有因一个问题引发的 国内外最牛逼的elasticsearch 天团博客集合。兄弟们 有玩过这个API的吗 ？这个suggest是干嘛作用的。死磕Elasticsearch 知...
Elasticsearch中国社区官方博客
Zijian Su的博客
05-29 2085
你好，我是Elastic的刘晓国。如果大家想开始学习Elastic的话，那么这里将是你理想的学习园地。在我的博客几乎涵盖了你想学习的许多方面。在这里，我来讲述一下作为一个菜鸟该如何阅读我的这些博客文章。 我们可以按照如下的步骤来学习： 1) Elastics...
elasticsearch
光英的记忆博客
05-29 1386
elasticsearch https://www.elastic.co/guide/cn/elasticsearch/guide/current/_search_lite.html https://github.com/elastic/elasticsearch
ElasticSearch官方测试数据
09-14
Elasticsearch（ES）是一种流行的开源全文搜索引擎，它基于Lucene库构建，被广泛用于大数据分析、日志聚合、实时搜索和索引等场景。官方提供的测试数据集是检验Elasticsearch功能、性能和稳定性的关键资源，可以帮助...
(狂神)ElasticSearch快速入门笔记，ElasticSearch基本操作以及爬虫(Java-ES仿京东实战)
04-18
(狂神)ElasticSearch快速入门笔记，ElasticSearch基本操作以及爬虫(Java-ES仿京东实战),包含了小狂神讲的东西，特别适合新手学习，笔记保存下来可以多看看。好记性不如烂笔头哦~，ElasticSearch，简称es，es是一个...
es docker 部署 elasticsearch.yml
03-19
docker run --name elasticsearch7.16.3 -p 127.0.0.1:9200:9200 -p 127.0.0.1:9300:9300 -e "discovery.type=single-node" -v /Users/xingyue/Home/xingyue/学习/工程化/es/elasticsearch.yml:/usr/share/elastic...
基于Spring框架开源ElasticSearch搜索
03-30
本书以实例讲述如何在Spring框架之上搭建ElasticSearch开发，以及如何利用JPA建立、更新和删除索引，如何配置ElasticSearch Server的applicationContext等。
Elasticsearch
qq_40699540的博客
11-02 308
全文检索 Elasticearch 研究 教学目标 了解Elasticsearch的应用场景 掌握索引维护的方法 掌握基本的搜索Api的使用方法 约束 1.阅读本教程之前需要掌握Lucene的索引方法、搜索方法 。 1 ElasticSearch介绍 1.1 介绍 [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-W2zce9Ba-1604249377462)(elasticsearch_img/1524301994916.png)] 官方网址：https://www....
Elasticsearch使用备忘
weixin_33910137的博客
07-07 112
最近我们需要对大约2T（6.5亿条）日志做全文检索，Elasticsearch看起来很火爆，又有很多产品使用（Facebook、github、stackoverflow），值得一试。以下是一些基础知识笔记。 Elasticsearch是一个基于Lucene构建的开源、分布式、RESTful的搜索引擎，能够实现近实时（NRT）搜索，稳定、可靠、安装方便。性能不错、水平扩展、文档齐全、社区火爆，这几...
lucene 倒排索引、反向索引概念明晰
04-21 1886
lucene中，一直在纠结什么叫倒排索引，为什么叫倒排索引，找了n个博客没有对该名词很透彻的解析，重于在知乎上中找到需要的答案： -------------------------------------------------------------------------------------------------- 渣翻译的例子之一。 英文原名Inverted index，
Elasticsearch（一）
持续Java学习中
07-17 469
Elasticsearch简介以及基本的环境搭建 文章目录1、Elasticsearch概述2、Elasticsearch和Solr得对比3、Elasticsearch的安装3.1、下载3.2、安装3.3、目录结构3.4、启动并访问测试3.5、安装可视化界面3.6、启动可视化界面3.7、访问对应端口3.8、修改Elasticsearch配置文件，解决跨域问题4、ELK概述5、Kibana概述5.1、Kibana下载5.2、Kibana安装5.3、Kibana启动5.4、访问测试5.5、汉化测试工具 .
Elasticsearch（二）
持续Java学习中
07-19 394
文章目录1、ES核心概念1.1、概述1.2、索引1.3、字段类型（mapping）1.4、文档（documents）1.5、倒排索引2、IK分词器2.1、下载2.2、安装2.3、查看插件列表2.4、使用Kibana进行测试2.5、编写我们对应字典3、Rest风格说明3.1、创建索引规则并添加数据3.2、创建索引规则3.3、获得规则信息3.4、修改索引规则3.5、删除索引规则3.6、打印ES的相关信息4、文档的基本操作（重点）4.1、添加数据4.2、查询数据4.3、更新数据4.4、删除数据4.5、复杂查询
elasticsearch 学习笔记
努力在追梦的路上
03-12 1204
1 基本概念1.1 接近实时（NRT）Elasticsearch 是一个接近实时的搜索平台，从索引一个文档到这个文档被搜索到有一个很小的延迟（通常是1s）1.2 集群（Cluster）一个集群就是由一个节点组织在一起，他们共同持有你全部的数据，并且一起提供索引与搜索功能。一个集群由一个唯一的名字标识，一个节点通常指定某个集群的名字来加入这个集群。 一个集群中只包含一个节点是合法的。另外你可以拥有
Elasticsearch的入门篇(一) - 介绍
gaopengsui的博客
06-12 303
前言 最近在学习Elasticsearch，在这里记录下自己的学习过程，以便于加深记忆，并希望可以帮助大家更好的理解Elasticsearch。 现在官方已经出了中文文档了，如果你想快速的学习使用Elasticsearch可以继续浏览此篇博客及后续博客，如果你想系统学习Elasticsearch，还是建议大家去看官方权威文档，地址：Elasticsearch: 权威指南 Elastics...
01-ES-QL for Community - Chinese 12.03 2023 Beijing
最新发布
12-03
"本次分享主要介绍了Elasticsearch的全新管道查询语言ES|QL，它旨在提供一种统一的查询体验，用于搜索、规则设定和警报等。ES|QL的开发历时约17个月，旨在提高数据调查的效率，简化数据处理，并作为分布式计算和横向...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值