添加链接 注册    登录
link之家
链接快照平台
  • 输入网页链接，自动生成快照
  • 标签化管理网页链接
相关文章推荐
挂过科的爆米花  ·  【道中华】大唐最有名的六匹马如何见证王朝一统 ...·  7 月前    · 
满身肌肉的凉面  ·  北京轨道交通建设加速延伸 ...·  7 月前    · 
绅士的围巾  ·  中国寺庙楹联_古寺名刹楹联-CSDN博客·  1 年前    · 
火星上的猴子  ·  新增多个航线航班 舟山普陀山机场将开启夏秋航季·  1 年前    · 
文武双全的围巾  ·  京九高铁的东西线之争，途经山东河南湖北安徽， ...·  1 年前    · 
link之家  ›  ElasticSearch学习笔记_耿鬼不会笑的博客
elasticsearch 中文分词 mysql创建索引 kibana
https://blog.csdn.net/A233666/article/details/122419045
爱看书的羽毛球
2 年前

RestFul概述

REST : 表现层状态转化(Representational State Transfer)，如果一个架构符合REST原则，就称它为 RESTful 架构风格。

资源 : 所谓"资源"，就是网络上的一个实体，或者说是网络上的一个具体信息

表现层 : 我们把"资源"具体呈现出来的形式，叫做它的"表现层"(Representation)。

状态转化(State Transfer):如果客户端想要操作服务器，必须通过某种手段，让服务器端发生"状态转 化"(State Transfer)。而这种转化是建立在表现层之上的，所以就是"表现层状态转化"。

REST原则就是指一个URL代表一个唯一资源，并且通过HTTP协议里面四个动词:GET、POST、PUT、DELETE对应四种服务器端的基本操作: GET用来获取资源，POST用来添加资源(也可以用于更新资源)，PUT用来更新资源，DELETE用来删除资源。

RestFul风格编程

非Rest风格的代码：

Rest风格的代码：

Rest设计原则: 

1.使用restURL替换传统URL参数作为URL整体
rest url: http: //localhost:8989/项目名/rest/findOne/21/
2.使用四种http动词(请求方式)对应服务端四种操作
@GetMapping、@PostMapping、@PutMapping、@DeleteMapping
3.通常服务返回数据都是 JSON格式 或者 XML格式

@RestController 
1.标识当前服务是基于restfu的架构风格
2.@RestController = @ResponseBody + @Controller组合
在类上添加 @RestController 之后，此类的方法上不必每个类都要写 @ResponseBody

全文检索概述
 

全文检索是计算机程序通过扫描文章中的每一个词，对每一个词建立一个索引，指明该词在文章中出现的次数和位置。当用户查询时根据建立的索引查找，类似于通过字典的检索字表查字的过程。
 

检索：索(建立索引)、检(检索索引)
 

全文检索（Full-Text Retrieval(检索)）以文本作为检索对象，找出含有指定词汇的文本。全面、准确和快速是衡量全文检索系统的关键指标。
 

关于全文检索，我们要知道：
 

1. 只处理文本。
 

2. 不处理语义。
 

  1.  
    搜索时英文不区分大小写
     
  2.  
    结果列表有相关度排序
     
 

ElasticSearch概述与安装
 

什么是ElasticSearch
 

ElasticSearch 简称 ES，是基于Apache Lucene构建的开源搜索引擎，是当前流行的企业级搜索引擎。Lucene本身就可以被认为迄今为止性能最好的一款开源搜索引擎工具包，但是lucene的API相对复杂，需要深厚的搜索理论。很难集成到实际的应用中去。但是ES是采用java语言编写，提供了简单易用的RestFul API，开发者可以使用其简单的RestFul API，开发相关的搜索功能，从而避免lucene的复杂性。
 

ES的诞生
 

多年前，一个叫做Shay Banon的刚结婚不久的失业开发者，由于妻子要去伦敦学习厨师，他便跟着也去了。在他找工作的过程中，为了给妻子构建一个食谱的搜索引擎，他开始构建一个早期版本的Lucene。
 

直接基于Lucene工作会比较困难，所以Shay开始抽象Lucene代码以便Java程序员可以在应用中添加搜索功能。他发布了他的第一个开源项目，做“Compass”
 

后来Shay找到一份工作，这份工作处在高性能和内存数据网格的分布式环境中，因此高性能的实时的、分布式的搜索引擎也是理所当然需要的。然后他决定重写Compass库使其成为一个独立的服务叫做Elasticsearch。
 

第一个公开版本出现在2010年2月，在那之后Elasticsearch已经成为Github上最受欢迎的项目之一，代码贡献者超过300人。一家主营Elasticsearch的公司就此成立，他们一边提供商业支持一边开发新功能，不过Elasticsearch将永远开源且对所有人可用。
 

Shay的妻子依旧等待着她的食谱搜索…
 

ES的应用场景
 

ES主要以轻量级JSON作为数据存储格式，这点与MongoDB有点类似，但它在读写性能上优于 MongoDB 。同时也支持地理位置查询 ，还方便地理位置和文本混合查询 。 以及在统计、日志类数据存储和分析、可视化这方面是引领者。
 

Wikipedia(维基百科)使用ES提供全文搜索并高亮关键字、
 

StackOverflow(IT问答网站)结合全文搜索与地理位置查询、
 

Github使用Elasticsearch检索1300亿行的代码。
 

百度(在云分析、网盟、预测、文库、钱包、风控等业务上都应用了ES，单集群每天导入30TB+数据， 总共每天60TB+)、
 

新浪 、阿里巴巴、腾讯等公司均有对ES的使用。
 

使用比较广泛的平台ELK(ElasticSearch, Logstash, Kibana)
 

ES的安装【Docker】
 

docker pull elasticsearch:6.8.20
docker pull kibana:6.8.20
docker images
docker network create somenetwork
docker run -d --name elasticsearch --net somenetwork -p 9200:9200 -p 9300:9300 -e "discovery.type=single-node" -e ES_JAVA_OPTS="-Xms256m -Xmx256m" elasticsearch:6.8.20
find / -name "kibana.yml"
vim /var/lib/docker/overlay2/0502650dfe5d47698b67d7d8637b90615fd0af20183ca7e6a825bb9172c9cde4/diff/usr/share/kibana/config/kibana.yml
docker run -d --name kibana --net somenetwork -p 5601:5601 kibana:6.8.20
docker logs -f kibana

验证elasticsearch是否安装成功：
 

http://192.168.228.130:9200/
 

验证kibana是否安装成功：
 

http://192.168.228.130:5601/
 

Kibana是一个针对Elasticsearch的开源分析及可视化平台，使用Kibana可以查询、查看并与存储在ES索引的数据进行交互操作，使用Kibana能执行高级的数据分析，并能以图表、表格和地图的形式查看数据。
 

Tips：你在左边缩写的语句，kibana会帮助你进行缓存，所以你不用担心kibana关闭后消失。
 

ES中的基本概念
 

接近实时(NRT Near Real Time )
 

Elasticsearch是一个接近实时的搜索平台。这意味着，从索引一个文档直到这个文档能够被搜索到有一个轻微的延迟 (通常是1秒内)
 

索引(index)
 

一个索引就是一个拥有几分相似特征的文档的集合。比如说，你可以有一个客户数据的索引，另一个产品目录的索引，还有一个订单数据的索引。一个索引由一个名字来标识(必须全部是小写字母的)，并且当我们要对这个索引中的文档进行索引、搜索、更新和删除的时候，都要使用到这个名字。索引类似于关系型数据库中Database 的概念。在一个集群中，如果你想，可以定义任意多的索引。
 

类型(type)
 

在一个索引中，你可以定义一种或多种类型。一个类型是你的索引的一个逻辑上的分类/分区，其语义完全由你来定。通常，会为具有一组共同字段的文档定义一个类型。比如说，我们假设你运营一个博客平台并且将你所有的数 据存储到一个索引中。在这个索引中，你可以为用户数据定义一个类型，为博客数据定义另一个类型，当然，也可 以为评论数据定义另一个类型。类型类似于关系型数据库中Table的概念。
 

NOTE: 在5.x版本以前可以在一个索引中定义多个类型，6.x之后版本也可以使用,但是不推荐，在7~8.x版本中彻底移除一个索引中创建多个类型
 

映射(Mapping)
 

Mapping是ES中的一个很重要的内容，它类似于传统关系型数据中table的schema(对表的约束：类型、长度、非空)，用于定义一个索引(index)中的类型(type)的数据的结构。 在ES中，我们可以手动创建type(相当于table)和mapping(相关与schema),也可以采用默认创建方式。
 

在默认配置下，ES可以根据插入的数据自动地创建type及其mapping。 mapping中主要包括字段名、字段数据类型和字段索引类型
 

文档(document)
 

一个文档是一个可被索引的基础信息单元，类似于表中的一条记录。比如，你可以拥有某一个员工的文档,也可以拥有某个商品的一个文档。文档以采用了轻量级的数据交换格式JSON(Javascript Object Notation)来表示。
 

以上为 ES版本5 中概念。
 

在 ES版本6 中发生了重大的改变：
 

在5.x版本以前可以在一个索引中定义多个类型，6.x之后版本也可以使用,但是不推荐，在7~8.x版本中彻底移除一个索引中创建多个类型
 

ES基本操作
 

索引(Index)
 

# 创建索引
PUT /ems
# 创建索引（含配置信息）
PUT /ems
  "settings": {
    "number_of_replicas": 1,
    "number_of_shards": 5
# 查看所有的索引
GET /_cat/indices
# 查看所有的索引（含表头信息）
# pri rep docs.count docs.deleted store.size pri.store.size
# 索引的默认主分片数量、副本分片数量、文档数、已删除的文档数、文档大小、主分片大小
# health：green 健壮、green 可用，不健壮、red 不可以
GET /_cat/indices?v
# 删除索引
DELETE /ems
# 删除所有索引
# 【谨慎使用】删除所有索引后，kibana不能正常运行（因为kibana需要 .kibana_task_manager 和 .kibana_1 ），除非重启kibana
DELETE /*

创建索引时不同版本信息：
 

翻译：从7.0开始时，默认的分片数量从 [5] 变成了 [1]，如果你还想使用 [5] 个分片，需要指定参数
 

索引必须使用：小写字母，可以使用 小写字母 + 数字
 

类型(type)
 

# 创建类型
PUT /ems
  "mappings": {
    "person":{
      "properties":{
        "id":{
          "type":"keyword"
        "name":{
          "type":"keyword"
        "age":{
          "type":"integer"
# 查看索引信息(mappings+setting)
GET /ems
# 查看类型信息(mappings)
GET /ems/_mapping

“mappimgs”：映射，固定写法，即对类型的数据结构进行约束，这样在添加文档时，就会有约束
 

“person”：即类型名，ES6之后建议一个索引创建一个类型
 

“properties”：属性，固定写法，即将类型所要创建的属性添加在里面
 

“name”…等：属性名
 

“type”：固定写法，约束类型，可以根据属性的不同写不同类型
 

  • Mapping Type: : text , keyword , date ,integer, long , double , boolean or ip
 

文档(document)
 

# 文档操作：插入一条文档：PUT/索引/类型/文档ID
# 需要指定文档ID
PUT /ems/person/1
  "id":"10086",
  "name":"zhangsan",
  "age":18
# 使用POST新增时
# 如果不指定ID则会自动创建一个 _id （是随机字符串，例：iU58hX0BZVIOpFfK5RDL），一般会自己创建
POST /ems/person/
  "id":"10086",
  "name":"zhangsan",
  "age":18
# 文档操作：根据ID查询文档中的一条记录
GET /ems/person/1
# 文档操作：根据文档ID删除
DELETE /ems/person/1

# 错误方式
POST /ems/person/1
  "name":"李四"
# 查看文档:覆盖掉了原有的属性信息，只有新更新的
  "_index" : "ems",
  "_type" : "person",
  "_id" : "1",
  "_version" : 2,
  "_seq_no" : 5,
  "_primary_term" : 1,
  "found" : true,
  "_source" : {
    "name" : "张三"

# 正确方式： 使用关键词_update
# 方式一：在原有数据基础上进行更新
# doc固定写死，这样就是先查询，在拿 doc 中数据更新
POST /ems/person/1/_update
  "doc": {
    "name":"李四"
# 第二种方式：添加新的约束的数据
# 这种方式，type并没有color属性，但你添加的时候，ES会给你进行相应的匹配
# ES `自动构建符合的类型`
POST /ems/person/1/_update
  "doc": {
    "bri":"2021-12-04"
# 第三种方式：根据script脚本进行更新[使用较少]
POST /ems/person/1/_update
  "script": "ctx._source.age += 5.0"

有时候，想要同时添加文档、删除文档、修改文档、索引文档组合进行
 

使用关键词 _bulk
 

根据关键词进行匹配，"index"创建（索引）、update更新、delete删除
 
 
【不确定】严格的JSON格式要求，JSON缩进 和 换行 要严格对应
 

# 同时添加多个文档
# 如果文档已经存在，则会进行覆盖
PUT /ems/person/_bulk
{"index":{"_id":"1"}}
  {"id":"1","name":"张三1","age":88}
{"index":{"_id":"2"}}
  {"id":"2","name":"张三2"}
{"index":{"_id":"3"}}
  {"name":"张三3"}
# 同时修改和删除文档
# POST 方式 或 PUT方式 都可以
POST /ems/person/_bulk
{"update":{"_id":"1"}}
  {"doc":{"name":"zhangsan"}}
{"delete":{"_id":"2"}}
{"index":{"_id":"4"}}
  {"id":"4","name":"张三4","age":88}
 
注意：所谓批量操作，简单说就是你想进行删除操作，你就使用"delete"关键词，想要进行修改操作，你就使用"update"关键词
 
 
批量时不会因为一个失败而全部失败,而是继续执行后续操作,批量在返回时按照执行的状态开始返回
 

最初刚学习ElasticSearch的时候，为了便于理解，我们将其与我们所学习的MySQL数据进行了类别学习
 

但是ElasticSearch相对于MySQL数据库，更好的我们叫它为索引库，它分为两个过程：先是建立索引，再是检索
 

ElasticSearch 对于不同的服务建立了不同的索引，每个索引又创建了类型[6以后只能创建一个]，同时对类型进行了约束，现在我们往ES中索引文档，它内部是怎样工作的呢？
 

现在我们添加按照其类型的约束添加“张三”这条数据，ES拿到这条数据后，首先把整个文档进行储存在元数据区，同时会生成对应的"_id"，比如这里为0，到时候我们拿0去查询，就可以得到这个文档；然后按照分词器[所谓分词器就是对你输入的数据，按照一定的规则进行划分，这里以标准分词器为例]进行划分，因为name属性是"text"类型，所以需要分词，按照规则，进行单字划分，先分“张”，然后记录这个字在右边哪个文档中出现，同时出现了几次[当然这里只是简单列举一下，实际情况可能更复杂]，再分“三”，一样的操作；接下来是"age"属性，因为age是"Integer"类型，所以不需要分词，直接存储，记录。一直如此操作，直到对输入的数据完成…
 

现在我们要插入第二条数据，同样是现在元数据区进行储存，为其分配"_id"，然后是索引区操作，现在"张"这个字不仅在0文档出现，也出现在1文档。
 

需求： 现在用户想要查找address为"北京"的文档，ES会进行两次搜索，先是在索引区[分词后存放的数据]找到相匹配的文档的"id"，再是按照"id"去找到元数据区对应的文档，最后按照：比如在0文档出现的次数多，就把0文档排在前面，展示给用户。
 

总结： 索引库储存数据，分为索引区和元数据区，元数据区储存完整文档，索引区存放分词过后的数据
 

ES中的高级检索
 

ES官方提供了两中检索方式：一种是通过 URL 参数进行搜索，另一种是通过 DSL(Domain Specified Language)进行搜索。
 

官方更推荐使用第二种方式，第二种方式是基于传递JSON作为请求体(request body)格式与ES进行交互，这种方式更强大，更简洁
 

  • URL查询: GET /索引/类型/_search?参数
  • DSL查询: GET /索引/类型/_search {}
 

# 1.删除索引
DELETE /ems
# 2.创建索引并指定类型
PUT /ems
  "mappings":{
    "emp":{
      "properties":{
        "name":{
          "type":"text"
        "age":{
          "type":"integer"
        "bir":{
          "type":"date"
        "content":{
          "type":"text"
        "address":{
          "type":"keyword"
# 3.插入测试数据
PUT /ems/emp/_bulk
  {"index":{}}
  {"name":"小黑","age":23,"bir":"2012-12-12","content":"为开发团队选择一款优秀的MVC框架是件难事儿，在众多可行的方案中决择需要很高的经验和水平","address":"北京"}
  {"index":{}}
  {"name":"王小黑","age":24,"bir":"2012-12-12","content":"Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式","address":"上海"}
  {"index":{}}
  {"name":"张小五","age":8,"bir":"2012-12-12","content":"Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善","address":"无锡"}
  {"index":{}}
  {"name":"win7","age":9,"bir":"2012-12-12","content":"Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？","address":"南京"}
  {"index":{}}
  {"name":"梅超风","age":43,"bir":"2012-12-12","content":"Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API","address":"杭州"}
  {"index":{}}
  {"name":"张无忌","age":59,"bir":"2012-12-12","content":"ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口","address":"北京"}

URL检索
 

【了解即可】
 

GET /ems/emp/_search?q=*&sort=age:desc&size=5&from=0&_source=name,age,bir

_search：搜索的API
q=* ：匹配所有文档
sort=age：按照指定字段进行排序，默认为升序，:desc 降序排列
size：展示多少条数据
from：展示第几页：from=(pageNow-1)*size
_source：只匹配哪些字段

DSL检索
 

【重点内容】
 
  "took" : 1, # 查询所用时间，毫秒
  "timed_out" : false, # 是否超时
  "_shards" : { # 分片
    "total" : 5, # 默认五个分片
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0




    

  "hits" : { # 击中对象
    "total" : 12, # 结果数
    "max_score" : 1.0, # 最大得分：搜索文档的相关度（查询所有，都是1.0）（动态计算）
    "hits" : [ # 查询结果
        "_index" : "ems",
        "_type" : "emp",
        "_id" : "YKFmjX0BymRyKg3XALu0",
        "_score" : 1.0,
        "_source" : {
          "name" : "梅超风",
          "age" : 43
      ......

0.查询所有(match_all)
 

match_all关键字: 返回索引中的全部文档
 

GET /ems/emp/_search
  "query": {
    "match_all": {}

1.查询结果中返回指定条数(size)
 

size 关键字: 指定查询结果中返回指定条数。 默认返回值10条
 

是对查询的结果进行处理
 

GET /ems/emp/_search
  "query": {
    "match_all": {}
  "size": 5

2.分页查询(from)
 

from 关键字: 用来指定起始返回位置，和size关键字连用可实现分页效果
 

GET /ems/emp/_search
  "query": {
    "match_all": {}
  "size": 5,
  "from": 0

3. 查询结果中返回指定字段(_source)
 

_source 关键字: 是一个数组,在数组中用来指定展示那些字段
 

# 展示单个字段
GET /ems/emp/_search
  "query": {
    "match_all": {}
  "_source": "name"
# 展示多个字段
GET /ems/emp/_search
  "query": {
    "match_all": {}
  "_source": ["name","age"]

4. 关键词查询(term)
 

term 关键字: 用来使用关键词查询
 

搜索时不区分大小写
 
 
type中，只有text类型是分词的，keyword integer date不分词
 

# name 是text类型，会进行分词，所以name包含“张”的文档都行
GET /ems/emp/_search
  "query": {
    "term": {
      "name": {
        "value": "张"
# bir 是date类型，不会进行分词，所以按照整体查询，查不到数据
GET /ems/emp/_search
  "query": {
    "term": {
      "bir": {
        "value": "2012-12"

NOTE1: 通过使用term查询得知ES中默认使用分词器为标准分词器(StandardAnalyzer),标准分词器对于英文单词分词,对于中文单字分词。
 

NOTE2: 通过使用term查询得知,在ES的Mapping Type 中 keyword , date ,integer, long , double , boolean or ip 这些类型不分词，只有text类型分词。
 

5. 范围查询(range)
 

range 关键字: 用来指定查询指定范围内的文档
 

当然只是针对一些特殊的字段比如age等
 

# 查询age>=5,<=10的文档
GET /ems/emp/_search
  "query": {
    "range": {
      "age": {
        "gte": 5,
        "lte": 10

gte：大于等于
 

lte：小于等于
 

gt：大于
 

lt：小于
 

6. 前缀查询(prefix)
 

prefix 关键字: 用来检索含有指定前缀的关键词的相关文档
 

GET /ems/emp/_search
  "query": {
    "prefix": {
      "name": {
        "value": "无"
# 结果：
  "took" : 11,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  "hits" : {
    "total" : 1,
    "max_score" : 1.0,
    "hits" : [
        "_index" : "ems",
        "_type" : "emp",
        "_id" : "BVSspHYBh-o7eO8i7bUf",
        "_score" : 1.0,
        "_source" : {
          "name" : "张无忌",
          "age" : 59,
          "bir" : "2012-12-12",
          "content" : "ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口",
          "address" : "北京"

注意： 指定的前缀并不是说元数据文档中name属性以"张"为前缀的，而是匹配的经过分词器分词后索引区的数据，这里"张无忌"经过分词后为：“张”,“无”,“忌”，无论匹配到哪个都会指向那份文档
 

7. 通配符查询(wildcard)
 

wildcard 关键字: 通配符查询 ? 用来匹配一个任意字符 * 用来匹配多个任意字符
 

GET /ems/emp/_search
  "query": {
    "wildcard": {
      "name": {
        "value": "张?"

这里的匹配也是针对索引区里面的数据
 

一般来说，？ 和 * 一般放在文字后面，放在前面就是 查询所有
 

8. 多id查询(ids)
 

ids 关键字 : 值为数组类型,用来根据一组id获取多个对应的文档
 

GET /ems/emp/_search
  "query": {
    "ids": {
      "values": ["AlSspHYBh-o7eO8i7bUf","BVSspHYBh-o7eO8i7bUf"]

9. 模糊查询(fuzzy)
 

最大的模糊错误，必须在0-2之间，
 

例如要查询到： elasticsearch，可以用：elasticsearch、elasticxearch、elasticxxarch
 

模糊的长度，跟字符的长度有关
 

长度为0…2，不允许有错误
 

长度为3…5，允许有一个错误
 

长度为>=5，允许有两个错误
 

fuzzy 关键字: 用来模糊查询含有指定关键字的文档
 

GET /ems/emp/_search
  "query": {
      "fuzzy": {
        "content": "sprin"
# 这里搜索的关键词长度为5，允许一次模糊，索引区的数据为spring能相应匹配，刚好差1

模糊查询的规则： fuzzy 模糊查询 最大模糊错误 必须在0-2之间
 

  • 搜索关键词长度为 2 不允许存在模糊 0
  • 搜索关键词长度为3-5 允许一次模糊 0 1
  • 搜索关键词长度大于5 允许最大2模糊
 

10. 布尔查询(bool)
 

bool 关键字: 用来组合多个条件实现复杂查询
 

  • must: 相当于&& 同时成立
  • should: 相当于|| 成立一个就行
  • must_not: 相当于! 不能满足任何一个
 

GET /ems/emp/_search
  "query": {
    "bool": {
      "must": [
          "range": {
            "age": {
              "gte": 5,
              "lte": 10
      "must_not": [
          "term": {
            "address": {
              "value": "南"

11. 高亮查询(highlight)
 

不属于查询，对查询结果做二次渲染
 

highlight 关键字: 可以让符合条件的文档中的关键词高亮
 

# 只高亮 name字段
GET /ems/emp/_search
  "query": {
    "term": {
      "name": {
        "value": "五"
  "highlight": {
    "fields": {
      "name":{}
# 高亮所有
  "highlight": {
    "fields": {
      "*":{}
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  "hits" : {
    "total" : 1,
    "max_score" : 0.2876821,
    "hits" : [
        "_index" : "ems",
        "_type" : "emp",
        "_id" : "AlSspHYBh-o7eO8i7bUf",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "张小五",
          "age" : 8,
          "bir" : "2012-12-12",
          "content" : "Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善",
          "address" : "无锡"
        "highlight" : {
          "name" : [
            "张小<em>五</em>"

highlight 是对查询后的结果进行高亮，所以要放在"query"之后进行，同时，并不是在原数据上进行操作，而是新增了，并增加的为
 

自定义高亮html标签: 可以在highlight中使用pre_tags和post_tags
 

GET /ems/emp/_search
  "query": {
    "term": {
      "name": {
        "value": "五"
  "highlight": {
    "pre_tags": ["<span style='color:red'>"], 
    "post_tags": ["</span>"], 
    "fields": {
      "name":{}
  "took" : 1,
  "timed_out" : false,
  "_shards" : {
    "total" : 5,
    "successful" : 5,
    "skipped" : 0,
    "failed" : 0
  "hits" : {
    "total" : 1,
    "max_score" : 0.2876821,
    "hits" : [
        "_index" : "ems",
        "_type" : "emp",
        "_id" : "AlSspHYBh-o7eO8i7bUf",
        "_score" : 0.2876821,
        "_source" : {
          "name" : "张小五",
          "age" : 8,
          "bir" : "2012-12-12",
          "content" : "Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善",
          "address" : "无锡"
        "highlight" : {
          "name" : [
            "张小<span style='color:red'>五</span>"

12. 多字段查询(multi_match)
 

有时候光进行一项字段匹配体验效果并不是很好，所以可以同时多字段匹配
 

GET /ems/emp/_search
  "query": {
    "multi_match": {
      "query": "中国", # 关键词
      "fields": ["name","content"]  #这里写要检索的指定字段

注意： 检索的关键词是否需要拆开来检索还需要看指定
 

的字段是否有分词
 

首先会对"query"进行分词，再进行分词
 

首先对于content可以分词，分为“北、京、Redis”，分别进行搜索
 

其次对于address不能分词，用“北京Redis”进行搜索
 

 "multi_match": {
      "query": "北京Redis", # 关键词
      "fields": ["content","address"]  #这里写要检索的指定字段

13. 多字段分词查询(query_string)
 

该关键词可以增加分词器
 

GET /dangdang/book/_search
  "query": {
    "query_string": {
      "query": "中国声音",
      "analyzer": "ik_max_word", 
      "fields": ["name","content"]

IK分词器
 

默认ES中采用标准分词器进行分词，这种方式并不适用于中文网站，因此需要修改ES对中文友好分词，从而达到更佳的搜索的效果
 

参考官网：
 

https://github.com/medcl/elasticsearch-analysis-ik

Docker安装IK
 

1、删除ES原始数据
 

因为之前可能使用的标准分词器，如果存在数据，现在又使用IK分词器会出现冲突，进入es安装目录中将data目录数据删除
 

docker exec -it f81 bash
rm -rf data

2、安装IK
 

docker exec -it f81 bash ./bin/elasticsearch-plugin install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v6.8.20/elasticsearch-analysis-ik-6.8.20.zip

3、查看IK
 

安装完成后会在plugins目录下，生成IK
 

docker exec -it f81 bash
ls plugins/

4、重启es
 

GET /_analyze
  "text": "中华人民共和国国歌",
  "analyzer": "ik_smart"
  "tokens" : [
      "token" : "中华人民共和国",
      "start_offset" : 0,
      "end_offset" : 7,
      "type" : "CN_WORD",
      "position" : 0
      "token" : "国歌",
      "start_offset" : 7,
      "end_offset" : 9,
      "type" : "CN_WORD",
      "position" : 1

IK分词类型
 

IK分词器提供了两种mapping类型用来做文档的分词分别是 ik_max_word 和 ik_smart
 

ik_max_word 和 ik_smart 什么区别?
 

  • ik_max_word: 会将文本做最细粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,中华人民,中华,华人,人民共和国,人民,人,民,共和国,共和,和,国国,国歌”，会穷尽各种可能的组合；
  • ik_smart: 会做最粗粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,国歌”
 

建立索引的分词器 和 搜索时的分词器 保持严格一致
 

默认情况下就会保持一致
 

# 删除原有的ems索引数据
DELETE /ems
# 新建索引/类型/约束
# 同时针对属性增加了使用IK分词器
PUT /ems
  "mappings":{
    "emp":{
      "properties":{
        "name":{
          "type":"text",
           "analyzer": "ik_max_word",
           "search_analyzer": "ik_max_word"
        "age":{
          "type":"integer"
        "bir":{
          "type":"date"
        "content":{
          "type":"text",
          "analyzer": "ik_max_word",
          "search_analyzer": "ik_max_word"
        "address":{
          "type":"keyword"
# 添加数据
PUT /ems/emp/_bulk
  {"index":{}}
  {"name":"小黑","age":23,"bir":"2012-12-12","content":"为开发团队选择一款优秀的MVC框架是件难事儿，在众多可行的方案中决择需要很高的经验和水平","address":"北京"}
  {"index":{}}
  {"name":"王小黑","age":24,"bir":"2012-12-12","content":"Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式","address":"上海"}
  {"index":{}}
  {"name":"张小五","age":8,"bir":"2012-12-12","content":"Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善","address":"无锡"}
  {"index":{}}
  {"name":"win7","age":9,"bir":"2012-12-12","content":"Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？","address":"南京"}
  {"index":{}}
  {"name":"梅超风","age":43,"bir":"2012-12-12","content":"Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API","address":"杭州"}
  {"index":{}}
  {"name":"张无忌","age":59,"bir":"2012-12-12","content":"ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口","address":"北京"}
GET /ems/emp/_search
  "query":{
    "term":{
      "content":"框架"
  "highlight": {
    "pre_tags": ["<span style='color:red'>"],
    "post_tags": ["</span>"],
    "fields": {
      "*":{}

IK配置扩展词
 

IK支持自定义 扩展词典 和 停用词典
 

扩展词典： 就是有些词并不是关键词,但是也希望被ES用来作为检索的关键词,可以将这些词加入扩展词典。
 

停用词典： 就是有些词是关键词,但是出于业务场景不想使用这些关键词被检索到，可以将这些词放入停用词典。
 

配置本地词典
 

这里采用的本地安装：可以修改IK分词器中config目录中 IKAnalyzer.cfg.xml 这个文件
 

1、建分词文件
 

进入安装的IK分词文件的config目录下，新建 ext.dic
 

NOTE：
 

  • 词典的编码必须为UTF-8，否则无法生效
  • 多个词要分行放置
 

填入你想要扩展的词：
 

2、改配置文件
 

一定要注意ES你采用的是哪种安装方式
 

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

3、重启ES
 

删除之前的数据 rm -rf data
 

GET /_analyze
  "text":"碰瓷",
  "analyzer": "ik_max_word"
  "tokens" : [
      "token" : "碰瓷"




    
,
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 0

配置的扩展器只针对配置过后索引的文档有效，之前已经索引的文档想要使用改扩展词，需要重新索引
 

操作和扩展一样，只是文件名在IKAnalyzer.cfg.xml中填入的位置不一样
 

配置远程词典
 

本地词典写入的词一旦写入，后面再想去填入或者停用，比较麻烦
 

比如，我这个博客网站我想根据用户输入的词的搜索达到多少后将其认定为热词添加到词典中，并且一段时间后进行一定的更新
 

EMS这个应用就相当于我们的博客，在这个下面我们创建了一个文件ext.txt，专门用于存放热词，而这个热词具体怎么来，我们可以结合redis，当用户搜索词的次数达到多少，我们通过IO写入这个文件中，然后ES通过监听url这个地址上的数据发生了变化，就进行相应的更新
 

1、建SpringBoot应用
 

2、改项目访问路径
 

想要访问到静态资源，需要修改一下配置
 

3、测试访问项目
 

之前我们一直使用localhost访问本地，但是后面需要在Linux端访问，所以需要用windows的ip地址：
 

使用：ipconfig查看
 

http://192.168.77.1:8888/ext.txt

4、改ES配置文件
 

vim 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">ex.dic</entry>
         <!--用户可以在这里配置自己的扩展停止词字典-->
        <entry key="ext_stopwords"></entry>
        <!--用户可以在这里配置远程扩展字典 -->
        <entry key="remote_ext_dict">http://192.168.77.1:8888/ext.txt</entry>
        <!--用户可以在这里配置远程扩展停止词字典-->
        <entry key="remote_ext_stopwords">http://192.168.77.1:8888/stop.txt</entry>
</properties>

5、重启ES
 

./elasticsearch

GET /_analyze
  "text":"打工人",
  "analyzer": "ik_max_word"
  "tokens" : [
      "token" : "打工人",
      "start_offset" : 0,
      "end_offset" : 3,
      "type" : "CN_WORD",
      "position" : 0
      "token" : "打工",
      "start_offset" : 0,
      "end_offset" : 2,
      "type" : "CN_WORD",
      "position" : 1
      "token" : "工人",
      "start_offset" : 1,
      "end_offset" : 3,
      "type" : "CN_WORD",
      "position" : 2

发现"打工人"这个词作为分词关键词了
 
 
继续测试：
 
 
1.我们在文本文件中添加一个新的词汇
 
 
2.等待SpringBoot项目相应（重启项目 或 热部署）
 
 
3.创建包含此词汇的文档
 
 
4.使用关键词查询该文档
 
 
5.注： 只有在新的词汇添加后的文档，才会为该词汇创建索引
 
 
下面我们试试停用分词
 
 
我们将"打工"这个词停用
 

在stop.txt中写入：
 

重启springboot项目
 

我们看一下ES界面的变化，它会去拉取远程需要加入或者停用的词到字典中
 

kibana 中测试：
 

GET /_analyze
  "text":"打工人",
  "analyzer": "ik_max_word"
  "tokens" : [
      "token" : "打工人",
      "start_offset" : 0,
      "end_offset" : 3,
      "type" : "CN_WORD",
      "position" : 0
      "token" : "工人",
      "start_offset" : 1,
      "end_offset" : 3,
      "type" : "CN_WORD",
      "position" : 1

发现就没有将"打工"这个词作为分词关键字了
 

Filter Query【过滤查询】
 

准确来说，ES中的查询操作分为2种: 查询(query)和过滤(filter)
 

查询即是之前提到的query查询，它 (查询)默认会计算每个返回文档的得分，然后根据得分排序。而过滤(filter)只会筛选出符合的文档，并不计算 得分，且它可以缓存文档 。所以，单从性能考虑，过滤比查询更快。
 

换句话说，过滤适合在大范围筛选数据，而查询则适合精确匹配数据。一般应用时， 应先使用过滤操作过滤数据， 然后使用查询匹配数据。
 
 
Filter Query(过滤查询)：不会计算文档得分，只做一个筛选操作
 
 
Filter 和 Query 是两种操作，他们之间使用 boolean连接
 

NOTE:
 

  • 在执行filter和query时,先执行filter在执行query
  • Elasticsearch会自动缓存经常使用的过滤器，以加快性能
  • 使用过滤查询必须使用bool查询
 

GET /ems/emp/_search
  "query": {
    "bool": {
      "must": [
         "term": {
           "name": {
             "value": "小五"
      "filter": {
        "range": {
          "age": {
            "gte": 1,
            "lte": 10

执行过程：
 

先从ES从执行过滤查询，找到符合年龄范围在[1,10]的文档，这个过程不会计算得分，
 

然后再执行查询操作，从满足条件的这些文档中又去查找"name"属性的值为"小五"的文档，并将可能的文档计算的得分。
 

常见的过滤器类型
 

term Filter
 

term 用在过滤中查询，表示查询指定字段含有该词的文档
 

GET /ems/emp/_search
  "query": {
    "bool": {
      "must": [
          "term": {
            "name": {
              "value": "小五"
      "filter": {
        "term": {
          "content": "spring"

terms Filter
 

term只能匹配一个字段，要想过滤多个字段，使用terms
 

GET /ems/emp/_search
  "query": {
    "bool": {
      "must": [
          "term": {
            "name": {
              "value": "小五"
      "filter": {
        "terms": {
          "content": ["spring","java"]

range Filter
 

顾名思义：就是先查找满足某个指定范围的字段
 

GET /ems/emp/_search
  "query": {
    "bool": {
      "must": [
         "term": {
           "name": {
             "value": "小五"
      "filter": {
        "range": {
          "age": {
            "gte": 1,
            "lte"




    
: 10

exists Filter
 

过滤存在指定字段，获取字段不为空的索引记录使用
 

GET /ems/emp/_search
  "query": {
    "bool": {
      "must": [
          "match_all": {}
      "filter": {
        "exists": {
          "field": "age"

ids Filter
 

查找含有指定字段的索引记录
 

GET /ems/emp/_search
  "query": {
    "bool": {
      "must": [
          "match_all": {}
      "filter": {
          "ids": {
            "values": [
              "1","OY0TqnYB5vZ1Et4zupDf"

Java 操作ElasticSearch
 

使用Java操作ES说明
 

实时索引：强一致性，数据库变化，es变化，完全一致
 

最终索引：最终一致性，过了一段时间之后，最终数据一致
 

最终数据一致性：
 

B站UP主视频播放信息统计，（只显示前一天为止的数据统计，一天更新一次）
 

1.建项目
 

2.改pom
 

引入依赖：
 

<dependency>
  <groupId>org.elasticsearch</groupId>
  <artifactId>elasticsearch</artifactId>
  <version>6.8.20</version>
</dependency>
<dependency>
  <groupId>org.elasticsearch.client</groupId>
  <artifactId>transport</artifactId>
  <version>6.8.20</version>
</dependency>
<dependency>
  <groupId>org.elasticsearch.plugin</groupId>
  <artifactId>transport-netty4-client</artifactId>
  <version>6.8.20</version>
</dependency>
<!--json格式转化-->
<dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.75</version>
</dependency>

3.建测试类
 

快捷键：ctrl + shift + t
 

索引相关操作
 

开始我们使用 kibana 客户端进行ES的操作
 

类比Kibana客户端的方式创建以下数据：
 

# 创建索引/类型、映射
# name 和 content 属性使用IK进行分词
PUT /ems
  "mappings":{
    "emp":{
      "properties":{
        "name":{
          "type":"text",
           "analyzer": "ik_max_word",
           "search_analyzer": "ik_max_word"
        "age":{
          "type":"integer"
        "bir":{
          "type":"date"
        "content":{
          "type":"text",
          "analyzer": "ik_max_word",
          "search_analyzer": "ik_max_word"
        "address":{
          "type":"keyword"
# 索引文档
PUT /ems/emp/_bulk
  {"index":{}}
  {"name":"小黑","age":23,"bir":"2012-12-12","content":"为开发团队选择一款优秀的MVC框架是件难事儿，在众多可行的方案中决择需要很高的经验和水平","address":"北京"}
  {"index":{}}
  {"name":"王小黑","age":24,"bir":"2012-12-12","content":"Spring 框架是一个分层架构，由 7 个定义良好的模块组成。Spring 模块构建在核心容器之上，核心容器定义了创建、配置和管理 bean 的方式","address":"上海"}
  {"index":{}}
  {"name":"张小五","age":8,"bir":"2012-12-12","content":"Spring Cloud 作为Java 语言的微服务框架，它依赖于Spring Boot，有快速开发、持续交付和容易部署等特点。Spring Cloud 的组件非常多，涉及微服务的方方面面，井在开源社区Spring 和Netflix 、Pivotal 两大公司的推动下越来越完善","address":"无锡"}
  {"index":{}}
  {"name":"win7","age":9,"bir":"2012-12-12","content":"Spring的目标是致力于全方位的简化Java开发。 这势必引出更多的解释， Spring是如何简化Java开发的？","address":"南京"}
  {"index":{}}
  {"name":"梅超风","age":43,"bir":"2012-12-12","content":"Redis是一个开源的使用ANSI C语言编写、支持网络、可基于内存亦可持久化的日志型、Key-Value数据库，并提供多种语言的API","address":"杭州"}
  {"index":{}}
  {"name":"张无忌","age":59,"bir":"2012-12-12","content":"ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口","address":




    
"北京"}

创建 ES 客户端
 

Java连接的端口是 9300
 

//创建 ES 客户端操作对象
@Test
public void testJavaClient() throws UnknownHostException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    // Kibanan连接ES的端口为9200,Java 连接ES的方式为TCP,所以使用的端口为9300
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"),9300));
    //ES相关操作
    //关闭连接
    transportClient.close();

开启测试，如果没有报错，就代表我们的连接成功！
 

@Test
public void testIndex() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"),9300));
    //创建索引：需要一个CreateIndexRequest 请求
    CreateIndexRequest indexRequest = new CreateIndexRequest("ems");
    CreateIndexResponse response = transportClient.admin().indices().create(indexRequest).get();
    System.out.println(response.isAcknowledged());//查看创建结果
    //关闭连接
    transportClient.close();

创建索引/类型/映射
 

一般我们是自己创建索引，然后操作文档
 

我们在kibana中定义索引/类型/映射，而这里索引和类型都通过api实现了，只需要我们定义映射，即
 

properties部分，要注意这里映射的格式必须是json格式，同时如果你从上面给的数据进行复制的话，还需要对其进行压缩。
 

@Test
public void testIndexAndType() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"),9300));
    //创建索引
    CreateIndexRequest indexRequest = new CreateIndexRequest("ems");
    //定义json格式的映射
    String mappingJson = "{\"properties\":{\"name\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"},\"age\":{\"type\":\"integer\"},\"sex\":{\"type\":\"keyword\"},\"content\":{\"type\":\"text\",\"analyzer\":\"ik_max_word\"}}}";
    indexRequest.mapping("emp",mappingJson, XContentType.JSON);
    //创建类型和映射
    CreateIndexResponse response = transportClient.admin().indices().create(indexRequest).get();
    System.out.println(response.isAcknowledged());//查看创建结果
    //关闭连接
    transportClient.close();

@Test
public void testDeleteIndex() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"),9300));
    //删除索引:需要一个DeleteIndexRequest请求
    DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("ems");
    AcknowledgedResponse response = transportClient.admin().indices().delete(deleteIndexRequest).get();
    System.out.println(response.isAcknowledged());
    //关闭连接
    transportClient.close();

文档相关操作
 

指定id索引文档
 

在kibana中我们索引文档时，可以指定id，也可以随机生成
 

@Test
public void testIndexDocument() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //指定id索引一条记录
    Emp emp = new Emp("1", "小肥羊", 18, new Date(), "小肥羊是一只单纯的羊,他很单纯！", "北京");
    String json = JSONObject.toJSONString(emp);
    //参数：索引、类型、自定义ID                                                             文档数据JSON格式，指定JSON类型                    




    

    IndexResponse indexResponse = transportClient.prepareIndex("ems", "emp", emp.getId()).setSource(json, XContentType.JSON).get();
    System.out.println(indexResponse.status());
    //关闭连接
    transportClient.close();

注意： 索引文档时，需要json格式
 

自定生成id索引文档
 

prepareIndex 时不传入第三个参数即可，ES会随机生成一个id
 

@Test
public void testIndexDocument() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //指定id索引一条记录
    Emp emp = new Emp(null, "棒棒娃", 20, new Date(), "棒棒娃是一只努力的人,他很努力！", "重庆");
    String s = JSONObject.toJSONString(emp);
    IndexResponse indexResponse = transportClient.prepareIndex("ems", "emp").setSource(s, XContentType.JSON).get();
    System.out.println(indexResponse.status());
    //关闭连接
    transportClient.close();

更新一条文档
 

我们需要保持原有文档数据不变，在此基础上进行更新
 

@Test
public void testUpdateDocument() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //更新文档
    Emp emp = new Emp();
    emp.setContent("帮帮娃今天去四川了！");
    String s = JSONObject.toJSONString(emp);
    UpdateResponse updateResponse = transportClient.prepareUpdate("ems","emp","1").setDoc(s,XContentType.JSON).get();
    System.out.println(updateResponse.status());
    //关闭连接
    transportClient.close();

setDoc 表示原有数据文档不变
 

JSON设置日期格式：
 

删除一条文档
 

传入我们所需要删除文档的id即可
 

@Test
public void testDeleteDocument() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //删除文档
    DeleteResponse deleteResponse = transportClient.prepareDelete("ems", "emp", "QqCqr3YBWFsguNUCcwL1").get();
    System.out.println(deleteResponse.status());
    //关闭连接
    transportClient.close();

查询一条文档
 

getReponse 获取的是 map对象，可以转为String，即 getResponse.getSourceAsString
 

获取map对象之后，可以把数据手动还原回去，其中要注意 日期格式
 

查询所有文档
 

关键词查询文档 term
 

批量操作文档
 

@Test
public void testBulkDocument() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //批量处理
    //1.添加文档
    IndexRequest indexRequest = new IndexRequest("ems","emp","3");
    Emp emp = new Emp("2", "小飞", 30, new Date(), "小飞飞往太空"




    
, "太空");
    String s = JSONObject.toJSONString(emp);
    indexRequest.source(s, XContentType.JSON);
    //2.更新文档
    UpdateRequest updateRequest = new UpdateRequest("ems","emp","1");
    Emp emp1 = new Emp();
    emp1.setName("中国军人");
    String s1 = JSONObject.toJSONString(emp1);
    updateRequest.doc(s, XContentType.JSON);
    //3.删除文档
    DeleteRequest deleteRequest = new DeleteRequest("ems", "emp", "1");
    //将需要执行的操作加入构建的bulk中:add可以添加多个
    BulkResponse itemResponses = transportClient.prepareBulk()
        .add(indexRequest)
        .add(updateRequest)
        .add(deleteRequest)
        .get();
    //ES批量操作不支持原子性：可以成功,可以失败
    BulkItemResponse[] items = itemResponses.getItems();
    for (BulkItemResponse b : items) {
        System.out.println(b.status());
    //关闭连接
    transportClient.close();

1. 查询所有并排序
 

查询所有并排序
 

  • ASC 升序 DESC 降序
  • addSort(“age”, SortOrder.ASC) 指定排序字段以及使用哪种方式排序
  • addSort(“age”, SortOrder.DESC) 指定排序字段以及使用哪种方式排序
 

打印查询结果：
 

@Test
public void testQueryMathAll() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //查询所有文档
    SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
        .setTypes("emp")//类型
        .setQuery(QueryBuilders.matchAllQuery()) //查询所有
        .addSort("age", SortOrder.DESC) //====>
        .get();//开始查询
    System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
    System.out.println("详细记录如下：");
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit h:hits) {
        System.out.println("当前索引分数:" + h.getScore());
        System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
        System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
    //关闭连接
    transportClient.close();

  • 如果按照指定字段进行排序展示，就打乱了分数排序的规则，其分数就会失效
 

如果想要将查询的结果进行封装，可以这样做：将结果映射返回到对象中
 

@Test
public void testQueryMathAll() throws UnknownHostException, ExecutionException, InterruptedException {
    List<Emp> list =  new ArrayList<>();
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //查询所有文档
    SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
        .setTypes("emp")//类型
        .setQuery(QueryBuilders.matchAllQuery()) //查询所有
        .addSort("age", SortOrder.DESC) //结果排序
        .get();//开始查询
    System.out.println(




    
"符合条件的总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
    System.out.println("详细记录如下：");
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit h:hits) {
        System.out.println("当前索引分数:" + h.getScore());
        System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
        System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
        Emp emp = new Emp();//=====>
        emp.setName((String) h.getSourceAsMap().get("name"));
        emp.setContent((String) h.getSourceAsMap().get("content"));
        list.add(emp);
    System.out.println(list);
    //关闭连接
    transportClient.close();

2. From Size分页查询
 

  • From 从那条记录开始 默认从0 开始 from = (pageNow-1)*size
  • Size 每次返回多少条符合条件的结果 默认10
 

注意是将查询后的结果进行分页
 

@Test
public void testQueryFromAndSize() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //查询所有文档
    SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
        .setTypes("emp")//类型
        .setQuery(QueryBuilders.matchAllQuery()) //传入查询的类型
        .setFrom(0) //====>
        .setSize(2)
        .get();//开始查询
    System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
    System.out.println("详细记录如下：");
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit h : hits) {
        System.out.println("当前索引分数:" + h.getScore());
        System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
        System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
    //关闭连接
    transportClient.close();

3. source 查询返回字段
 
 *  查询返回指定字段(source) 默认返回所有:
 *      setFetchSource 参数1:包含哪些字段   参数2:排除哪些字段
 *      setFetchSource("*","age")  返回所有字段中排除age字段
 *      setFetchSource("name","")  只返回name字段
 *      setFetchSource(new String[]{},new String[]{})
@Test
public void testQuerySource() throws UnknownHostException, ExecutionException, InterruptedException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //查询所有文档
    SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
        .setTypes("emp")//类型
        .setQuery(QueryBuilders.matchAllQuery()) //传入查询的类型
        .setFetchSource("*","age") //====>
        .get




    
();//开始查询
    System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
    System.out.println("详细记录如下：");
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit h : hits) {
        System.out.println("当前索引分数:" + h.getScore());
        System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
        System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
    //关闭连接
    transportClient.close();

3.5 方法模板
 

后面几个由于其写法大致差不多，只是传入查询的类型不一样，我将其封装为一个方法，到时候根据查询的不同传入不同的参数即可
 

public void queryTemplate(QueryBuilder query) throws UnknownHostException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //查询所有文档
    SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
        .setTypes("emp")//类型
        .setQuery(query) //传入查询的类型
        .get();//开始查询
    System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
    System.out.println("详细记录如下：");
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit h : hits) {
        System.out.println("当前索引分数:" + h.getScore());
        System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
        System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
    //关闭连接
    transportClient.close();

4. term 指定查询
 

查询指定字段含有指定值
 

@Test
public void testTermQuery() throws UnknownHostException {
    TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "飞");
    queryTemplate(termQueryBuilder);

5. range 范围查询
 
*  rang查询
*     lt    小于
*     lte   小于等于
*     gt    大于
*     gte   大于等于
@Test
public void testRange() throws UnknownHostException {
    RangeQueryBuilder rangeQueryBuilder = QueryBuilders.rangeQuery("age").gte(10).lte(20);
    queryTemplate(rangeQueryBuilder);

6.prefix 前缀查询
 

查询指定属性[根据是否分词后的结果]是否含有指定的前缀
 

@Test
public void testPrefix() throws UnknownHostException {
    PrefixQueryBuilder prefixQueryBuilder = QueryBuilders.prefixQuery("name", "小");
    queryTemplate(prefixQueryBuilder);

7.wildcard 通配符查询
 

根据通配符类型进行补全后查询
 

  • ? ：补全一个字符
  • *：补全任意字符
 

@Test
public void testWildcardQuery() throws UnknownHostException {
    WildcardQueryBuilder wildcardQuery = QueryBuilders.wildcardQuery("content", "小*");
    queryTemplate(wildcardQuery);

8.Ids 指定id查询
 

注意：这里要查询的id紧跟后面书写
 

@Test
public void testIds() throws UnknownHostException {
    IdsQueryBuilder queryBuilder = QueryBuilders.idsQuery().




    
addIds("1","3");
    queryTemplate(queryBuilder);

9.fuzzy 模糊查询
 

根据查询的大小，可以模糊不同的个数
 

  • 查询的个数0-2：必须和ES的词条完全匹配
  • 3-5：可以模糊一个
  • 大于5：可以模糊两个
 
    public void testFuzzy() throws UnknownHostException {
    FuzzyQueryBuilder fuzzyQueryBuilder = QueryBuilders.fuzzyQuery("content", "努力");
    queryTemplate(fuzzyQueryBuilder);

10.bool 复杂查询
 

可以有不同组合：传入的参数为同一类型
 

  • must()：查询必须满足的
  • mustNot()：查询相反的
  • should()：只要满足就行
 

@Test
public void testBool() throws UnknownHostException {
    BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
    boolQueryBuilder.must(QueryBuilders.termQuery("age","30"));
    boolQueryBuilder.should(QueryBuilders.prefixQuery("content","努"));
    queryTemplate(boolQueryBuilder);

10.5 指定返回字段
 

11.高亮查询
 
     * 高亮查询
     *  .highlighter(highlightBuilder) 用来指定高亮设置
     *  requireFieldMatch(false) 开启多个字段高亮 [默认只高亮匹配部分]
     *  field 用来定义高亮字段
     *  preTags("<span style='color:red'>")  用来指定高亮前缀
     *  postTags("</span>") 用来指定高亮后缀
@Test
public void testHighlight() throws UnknownHostException {
    //===>高亮配置
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.requireFieldMatch(false);//默认只渲染匹配的字段
    highlightBuilder.field("name");
    highlightBuilder.field("content");
    highlightBuilder.preTags("<span style='color:red'>");
    highlightBuilder.postTags("</span>");
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //查询所有文档
    SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
        .setTypes("emp")//类型
        .setQuery(QueryBuilders.termQuery("content","努力")) //====>
        .highlighter(highlightBuilder)//====>
        .get();//开始查询
    System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
    System.out.println("详细记录如下：");
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit h : hits) {
        System.out.println("当前索引分数:" + h.getScore());
        System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
        System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
    //关闭连接
    transportClient.close();

高亮数据和原数据是分开显示的，如何将高亮部分存入对象：先将原数据存入对象，再把高亮部分遍历出来替换掉需要高亮显示的部分
 

@Test
public void testHighlight() throws UnknownHostException {
    //用于储存数据:===>
    List<Emp> list = new ArrayList<>();
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.requireFieldMatch(false);//默认只渲染匹配的字段
    highlightBuilder.field("name");
    highlightBuilder.field("content");
    highlightBuilder.preTags("<span style='color:red'>");
    highlightBuilder.postTags("</span>");
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //查询所有文档
    SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
        .setTypes




    
("emp")//类型
        .setQuery(QueryBuilders.termQuery("content", "努力")) //====>
        .highlighter(highlightBuilder)//====>
        .get();//开始查询
    System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最高得分:" + searchResponse.getHits().getMaxScore());
    System.out.println("详细记录如下：");
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit h : hits) {
        System.out.println("当前索引分数:" + h.getScore());
        System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
        System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
        //打印高亮部分
        System.out.println(h.getHighlightFields());
        //原数据
        Emp emp = new Emp();
        emp.setName((String) h.getSourceAsMap().get("name"));
        emp.setAge((Integer) h.getSourceAsMap().get("age"));
        emp.setAddress((String) h.getSourceAsMap().get("address"));
        //高亮数据
        Map<String, HighlightField> highlightFields = h.getHighlightFields();
        if (highlightFields.containsKey("name")) {
            String nameHigh = highlightFields.get("name").fragments()[0].toString();
            emp.setName(nameHigh);
        if (highlightFields.containsKey("content")) {
            String contentHigh = highlightFields.get("content").fragments()[0].toString();
            emp.setContent(contentHigh);
        list.add(emp);
    //遍历集合
    System.out.println("对象方式显示高亮部分===>:");
    list.forEach(emp -> {
        System.out.println(emp);
    });
    //关闭连接
    transportClient.close();

FilterQuery 过滤查询
 

过滤查询主要用于查询执行之前对大量数据进行筛选
 

@Test
public void testFilterQuery() throws UnknownHostException {
    //创建连接
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //查询所有文档
    SearchResponse searchResponse = transportClient.prepareSearch("ems")//索引
        .setTypes("emp")//类型
        .setPostFilter(QueryBuilders.rangeQuery("age").gte(21).lte(30))//===>过滤
        .setQuery(QueryBuilders.matchAllQuery()) //===>传入查询的类型
        .get();//开始查询
    System.out.println("符合条件的总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最高得分:" + searchResponse.getHits().




    
getMaxScore());
    System.out.println("详细记录如下：");
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit h : hits) {
        System.out.println("当前索引分数:" + h.getScore());
        System.out.println("[字符串形式打印]====>" + h.getSourceAsString());
        System.out.println("[map集合形式打印]====>" + h.getSourceAsMap());
    //关闭连接
    transportClient.close();

注意setQuery的顺序：
 

@Test
public void testTotal() throws UnknownHostException {
    //1.创建客户端
    TransportClient transportClient = new PreBuiltTransportClient(Settings.EMPTY);
    transportClient.addTransportAddress(new TransportAddress(InetAddress.getByName("192.168.77.138"), 9300));
    //es操作
    SearchResponse searchResponse = transportClient.prepareSearch("ems1")
        .setTypes("emp") //类型
        .setFrom(0) //分页
        .setSize(20)
        .addSort("age", SortOrder.DESC) //排序
        .setPostFilter(QueryBuilders.rangeQuery("age").gte(10).lte(30)) //过滤
        .setSource(SearchSourceBuilder.searchSource().fetchSource("*", "bir"))//过滤条件
        .setQuery(QueryBuilders.multiMatchQuery("小黑最爱框架部分", "name", "content"))//===>查询【有顺序要求：仅高亮在之后】
        .highlighter(new HighlightBuilder().field("*").requireFieldMatch(false).preTags("<span style='color:red>").postTags("</span>")) //高亮部分[高亮搜寻字段]
        .get();
    System.out.println("总条数:" + searchResponse.getHits().getTotalHits());
    System.out.println("最大得分:" + searchResponse.getHits().getMaxScore());
    SearchHit[] hits = searchResponse.getHits().getHits();
    for (SearchHit s : hits) {
        System.out.println("原文档部分:" + s.getSourceAsString());
        System.out.println("高亮部分:" + s.getHighlightFields());
    //关闭连接
    transportClient.close();

SpringData整合ES
 

SpringBoot和SpringData和ES版本对应关系
 

注意如果你使用自动引入依赖，默认使用的springboot版本为最新的，需要将版本改低一点！！！
 

        <!--elasticsearch for springboot-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-elasticsearch</artifactId>
        </dependency> 

Transport客户端在7版本中不建议使用，在8版本中废除
 

SpringData也不建议使用Transport，而是使用 HighLevelRESTClient
 

两种方式：推荐第二种
 

如果因为版本关系等问题，第二种方式起不来，可以考虑使用第一种
 

注意：第一种 和 第二种方式 连接的端口号不一样
 

方式一：spring-data(2~3.x版本配置) ==> Transport客户端，不建议使用
 

spring:
  data:
    elasticsearch:
      cluster-nodes: 192.168.77.138:9300

方式二： spring-data(新版本推荐配置) RestHighLevelClient rest客户端 ElasticSearchRespositoy接口
 

@Configuration
public class RestClientConfig extends AbstractElasticsearchConfiguration {
    @Override
    @Bean
    public RestHighLevelClient elasticsearchClient() {
        final ClientConfiguration clientConfiguration = ClientConfiguration.builder()
            .connectedTo("192.168.77.138:9200")  //===>与kibana客户端类型都是restful分格,都是连接9200端口
            .build();
        return RestClients.create(clientConfiguration).rest();

ElasticSearchRespositoy
 

对一些简单的crud操作，可以使用 ElasticSearchRespositoy 接口
 

ElasticSearchRespositoy接口提供了一组CRUD的方法
 

而且自动做到了 对象->JSON，JSON到对象
 

只提供了基本的方法，想要复杂实现还需要使用 RestHighLevelClient ，例如：高亮，复杂条件查询




    

 

通过自定义接口继承ES提供的ElasticsearchRepository接口来实现
 

ElasticsearchRepository ：ES提供的操作CRUD接口
 
推荐文章
挂过科的爆米花  ·  【道中华】大唐最有名的六匹马如何见证王朝一统的艰险？ | 民族交往铸丹青之③
7 月前
满身肌肉的凉面  ·  北京轨道交通建设加速延伸 过去5年运营总里程翻番－国务院国有资产监督管理委员会
7 月前
绅士的围巾  ·  中国寺庙楹联_古寺名刹楹联-CSDN博客
1 年前
火星上的猴子  ·  新增多个航线航班 舟山普陀山机场将开启夏秋航季
1 年前
文武双全的围巾  ·  京九高铁的东西线之争，途经山东河南湖北安徽，你支持哪一个？
1 年前
今天看啥   ·   Py中国   ·   codingpro   ·   小百科   ·   link之家   ·   卧龙AI搜索
删除内容请联系邮箱 2879853325@qq.com
link之家 - 链接快照平台
© 2024 ~ 沪ICP备11025650号