学习笔记

ElasticSearch

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

正向索引

正向索引是最传统的，根据id索引的方式。但根据词条查询时，必须先逐条获取每个文档，然后判断文档中是否包含所需要的词条，是根据文档找词条的过程

优点：
可以给多个字段创建索引
根据索引字段搜索、排序速度非常快
缺点：
根据非索引字段，或者索引字段中的部分词条查找时，只能全表扫描

倒排索引

倒排索引是先找到用户要搜索的词条，根据词条得到保护词条的文档的id，然后根据id获取文档。是根据词条找文档的过程

倒排索引是对正向索引的一种特殊处理

将每一个文档的数据利用算法分词，得到一个个词条
创建表，每行数据包括词条、词条所在文档id、位置等信息
因为词条唯一性，可以给词条创建索引，例如hash表结构索引

优点：
根据词条搜索、模糊搜索时，速度非常快
缺点：
只能给词条创建索引，而不是字段
无法根据字段做排序

==文档和字段==

elasticsearch是面向文档（Document）存储的，可以是数据库中的一条商品数据，一个订单信息。文档数据会被序列化为json格式后存储在elasticsearch中,而Json文档中往往包含很多的字段（Field），类似于数据库中的列

==索引和映射==

**索引（Index）**就是相同类型的文档的集合,可以把索引当做是数据库中的表
**映射（mapping）**是索引中文档的字段约束信息，类似表的结构约束

==mysql与elasticsearch==

MySQL	Elasticsearch	说明
Table	Index	索引(index)，就是文档的集合，类似数据库的表(table)
Row	Document	文档（Document），就是一条条的数据，类似数据库中的行（Row），文档都是JSON格式
Column	Field	字段（Field），就是JSON文档中的字段，类似数据库中的列（Column）
Schema	Mapping	Mapping（映射）是索引中文档的约束，例如字段类型约束。类似数据库的表结构（Schema）
SQL	DSL	DSL是elasticsearch提供的JSON风格的请求语句，用来操作elasticsearch，实现CRUD

Mysql 擅长事务类型操作，可以确保数据的安全和一致性
Elasticsearch 擅长海量数据的搜索、分析、计算

文档一条数据就是一个文档，es中是Json格式
字段 Json文档中的字段
索引同类型文档的集合
映射索引中文档的约束，比如字段名称、类型

elasticsearch,kibana安装

==⭐elasticsearch 8.x版本首次运行会生成kibana需要的验证码==

docker pull elasticsearch:7.17.7
docker pull kibana:7.17.7

创建一个网络让es和kibana容器互联

docker network create es-net

es数据卷挂载需要设置权限

sudo chown 1000:1000 <directory you wish to mount>

启动elasticsearch

docker run -d --name es \
    -e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
    -e "discovery.type=single-node" \
    -v $PWD/es-data:/usr/share/elasticsearch/data \
    -v $PWD/es-plugins:/usr/share/elasticsearch/plugins \
    --privileged \
    --network es-net \
    -p 9200:9200 \
    -p 9300:9300 \
elasticsearch:7.17.7

-e "cluster.name=es-docker-cluster"：设置集群名称
-e "http.host=0.0.0.0"：监听的地址，可以外网访问
-e "ES_JAVA_OPTS=-Xms512m -Xmx512m"：内存大小
-e "discovery.type=single-node"：非集群模式
-v es-data:/usr/share/elasticsearch/data：挂载逻辑卷，绑定es的数据目录
-v es-logs:/usr/share/elasticsearch/logs：挂载逻辑卷，绑定es的日志目录
-v es-plugins:/usr/share/elasticsearch/plugins：挂载逻辑卷，绑定es的插件目录
--privileged：授予逻辑卷访问权
--network es-net ：加入一个名为es-net的网络中
-p 9200:9200：端口映射配置

启动kibana

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

--network es-net ：加入一个名为es-net的网络中，与elasticsearch在同一个网络中
-e ELASTICSEARCH_HOSTS=http://es:9200"：设置elasticsearch的地址，因为kibana已经与elasticsearch在一个网络，因此可以用容器名直接访问elasticsearch
-p 5601:5601：端口映射配置

分词器

es在创建倒排索引时需要对文档分词;在搜索时，需要对用户输入内容分词。但默认的分词规则对中文处理并不友好,处理中文分词一般会使用IK分词器,IK分词器包含两种模式

ik_smart 智能切分，粗粒度
ik_max_word 最细切分，细粒度

安装分词器

在线安装

# 进入容器内部
docker exec -it elasticsearch /bin/bash

# 在线下载并安装
./bin/elasticsearch-plugin  install https://github.com/medcl/elasticsearch-analysis-ik/releases/download/v7.17.7/elasticsearch-analysis-ik-7.17.7.zip

#退出
exit
#重启容器
docker restart elasticsearch

离线安装

安装插件需要知道elasticsearch的plugins目录位置，而我们用了数据卷挂载，因此需要查看elasticsearch的数据卷目录==ik分词的版本和es的版本要一致==

docker volume inspect es-plugins

将下载好的压缩包解压后上传到数据卷中

demo

json

POST /_analyze
{
  "analyzer": "ik_smart",
  "text": "我在湖南化工职业技术学院学习"
}

_analyze分词

ik_smart分词

ik_max_word分词

扩展词库

修改分词器config目录下的IKAnalyzer.xml文件

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

在ext.dic的文件中添加扩展的词语

在stopword.dic文件中禁止的词语

索引库操作

mapping属性是对索引库中文档的约束,常见的mapping属性

type 字段常用数据类型
- 字符串 text(可分词), keyword(精确度,不可分词)
- 数值 long integer short byte double float
- 布尔 boolean
- 日期 date
- 对象 object
index 是否创建索引,默认为true
analyzer 使用哪种分词器
properties 该字段的子字段

es中通过Restful 请求操作索引库,文档,请求内容用DSL语句来表达

创建索引库

json

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

查看索引库

GET /索引库名

删除索引库

DELETE /索引库名

==索引库一旦创建，无法修改mapping,但是可以添加新的字段==

json

PUT /user/_mapping
{
  "properties": {
    "age": {
      "type": "integer",
      "index": false
    }
  }
}

文档操作

新增文档POST /索引库名/_doc/文档id

json

POST /user/_doc/1
{
  "info": "湖南化工大三学生",
  "age": 18,
  "email": "zs@136.com",
  "name": {
    "firstName": "张",
    "lastName": "三"
  }
}

查看文档get /索引库名/_doc/文档id

GET /user/_doc/1

修改文档

全量修改 PUT(POST) /索引库名/_doc/文档id

json

PUT /user/_doc/1
{
  "info": "大三学生",
  "age": 18,
  "email": "zs@136.com",
  "name": {
    "firstName": "李",
    "lastName": "四"
  }
}

增量修改 POST /索引库名/_update/文档id

json

POST /user/_update/1
{
  "doc": {
    "age": 20
  }
}

创建文档：POST /{索引库名}/_doc/文档id
查询文档：GET /{索引库名}/_doc/文档id
删除文档：DELETE /{索引库名}/_doc/文档id
修改文档：
全量修改：PUT /{索引库名}/_doc/文档id
增量修改：POST /{索引库名}/_update/文档id { "doc": {字段}}

RestAPI

ES官方提供了各种不同语言的客户端，用来操作ES。这些客户端的本质就是组装DSL语句，通过http请求发送给ES

其中的Java Rest Client又包括两种：

Java Low Level Rest Client
Java High Level Rest Client

创建索引库

json

PUT /hotel {
  "mappings": {
    "properties": {
      "id": {
        "type": "keyword"
      },
      "name": {
        "type": "text",
        "analyzer": "ik_smart",
        "copy_to": "{all}"
      },
      "address": {
        "type": "keyword",
        "index": false
      },
      "price": {
        "type": "integer"
      },
      "score": {
        "type": "integer"
      },
      "brand": {
        "type": "keyword",
        "copy_to": "{all}"
      },
      "city": {
        "type": "keyword",
        "copy_to": "{all}"
      },
      "star_name": {
        "type": "keyword",
        "copy_to": "{all}"
      },
      "business": {
        "type": "keyword",
        "copy_to": "{all}"
      },
      "location": {
        "type": "geo_point"
      },
      "pic": {
        "type": "keyword",
        "index": false
      },
      "all": {
        "type": "text",
        "analyzer": "ik_smart"
      }
    }
  }
}

location：地理坐标，里面包含精度、纬度
all：一个组合字段，其目的是将多字段的值利用copy_to合并，提供给用户搜索

初始化RestClient

导入依赖

xml

<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://12.0.0.1:9200")
));

索引库操作

创建索引库

java

@Test
void createHotelIndex() throws IOException {
    //创建request对象
    CreateIndexRequest request = new CreateIndexRequest( INDEX_NAME );
    //请求参数
    request.source( MAPPING_TEMPLATE, XContentType.JSON );
    //发送请求创建索引库
    client.indices().create( request, RequestOptions.DEFAULT );
}

删除索引库

java

@Test
void deleteIndex() throws IOException {
    DeleteIndexRequest request = new DeleteIndexRequest( INDEX_NAME );
    client.indices().delete( request,RequestOptions.DEFAULT );
}

索引是否存在

java

@Test
    void isExistIndex() throws IOException {
        GetIndexRequest request = new GetIndexRequest( INDEX_NAME );
        boolean exists = client.indices().exists( request, RequestOptions.DEFAULT );
        log.info( exists ? "索引库存在" : "索引库不存在" );
    }
}

文档操作

插入文档

java

@Test
void insertDoc() throws IOException {
    IndexRequest request = new IndexRequest( INDEX_NAME ).id( "36934" );
    request.source( 
        "price","446",
        "starName","三钻",XContentType.JSON
    );
    client.index( request,RequestOptions.DEFAULT );
}

查询文档

java

@Test
void queryDoc() throws IOException {
    GetRequest request = new GetRequest( INDEX_NAME,"36934" );
    GetResponse documentFields = client.get( request, RequestOptions.DEFAULT );
    System.out.println( documentFields.getSourceAsString() );
}

删除文档

java

@Test
void deleteDoc() throws IOException {
    DeleteRequest request = new DeleteRequest( INDEX_NAME,"36934" );
    DeleteResponse delete = client.delete( request, RequestOptions.DEFAULT );
    System.out.println( delete.status() );
}

修改文档

java

@Test
void updateDoc() throws IOException {
    UpdateRequest request = new UpdateRequest( "hotel", "36934" );
    request.doc(
        "price","446",
        "starName","三钻"
    );
    client.update( request,RequestOptions.DEFAULT );
}

批量操作

java

@Test
void bulkInsert(){
    //获取数据
    List<Hotel> hotels = hotelService.list();
    BulkRequest request = new BulkRequest();
    hotels.forEach( hotel -> {
        HotelDoc hotelDoc = new HotelDoc( hotel );
        //创建文档request
        IndexRequest index = new IndexRequest( "hotel" ).id( hotelDoc.getId().toString() );
        index.source( JSON.toJSONString( hotelDoc ),XContentType.JSON );
        //添加数据
        request.add( index );
        //批量插入
        try {
            client.bulk( request,RequestOptions.DEFAULT );
        } catch ( IOException e ) {
            throw new RuntimeException( e );
        }
    } );
}

查询文档

分类查询

Elasticsearch提供了基于JSON的DSL（Domain Specific Language）来定义查询

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

match_all

json

// 查询所有
GET /indexName/_search
{
  "query": {
    "match_all": {
    }
  }
}

全文检索查询

对用户搜索的内容做分词，得到词条
根据词条去倒排索引库中匹配，得到文档id
根据文档id找到文档，返回给用户

match单字段查询

json

GET /hotel/_search
{
  "query": {
    "match": {
      "all": "上海"
    }
  }
}

multi_match多字段查询

json

GET /hotel/_search
{
  "query": {
    "multi_match": {
      "query": "上海外滩",
      "fields": ["name","brand"]
    }
  }
}

搜索字段越多，对查询性能影响越大，建议采用copy_to，然后单字段查询的方式

精确查询

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

term：根据词条精确值查询
range：根据值的范围查询

term查询

精确查询的字段搜是不分词的字段，因此查询的条件也必须是不分词的词条。查询时，用户输入的内容跟自动值完全匹配时才认为符合条件。如果用户输入的内容过多，反而搜索不到数据

json

GET /hotel/_search
{
  "query": {
    "term": {
      "id": {
        "value": "60487"
      }
    }
  }
}

range查询

json

GET /hotel/_search
{
  "query": {
    "range": {
      "price": {
        "gte": 100,
        "lte": 200
      }
    }
  }
}

地理坐标查询

geo_bounding_box查询

查询时，需要指定矩形的左上、右下两个点的坐标，然后画出一个矩形，落在该矩形内的都是符合条件的点

json

// geo_bounding_box查询
GET /indexName/_search
{
  "query": {
    "geo_bounding_box": {
      "FIELD": {
        "top_left": { // 左上点
          "lat": 31.1,
          "lon": 121.5
        },
        "bottom_right": { // 右下点
          "lat": 30.9,
          "lon": 121.7
        }
      }
    }
  }
}

geo_distance查询

查询到指定中心点小于某个距离值的所有文档。

json

// geo_distance 查询
GET /indexName/_search
{
  "query": {
    "geo_distance": {
      "distance": "15km", // 半径
      "FIELD": "31.21,121.5" // 圆心
    }
  }
}

复合查询

复合（compound）查询：复合查询可以将其它简单查询组合起来，实现更复杂的搜索逻辑。常见的有两种：

fuction score：算分函数查询，可以控制文档相关性算分，控制文档排名
bool：布尔查询，利用逻辑关系组合多个其它的查询，实现复杂搜索

相关性算分

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

TF-IDF算法有一各缺陷，就是词条频率越高，文档得分也会越高，单个词条对文档影响较大。而BM25则会让单个词条的算分有一个上限，曲线更加平滑

function score 查询

原始查询条件：query部分，基于这个条件搜索文档，并且基于BM25算法给文档打分，原始算分（query score)
过滤条件：filter部分，符合该条件的文档才会重新算分
算分函数：符合filter条件的文档要根据这个函数做运算，得到的函数算分（function score），有四种函数
- weight：函数结果是常量
- field_value_factor：以文档中的某个字段值作为函数结果
- random_score：以随机数作为函数结果
- script_score：自定义算分函数算法
运算模式：算分函数的结果、原始查询的相关性算分，两者之间的运算方式，包括：
- multiply：相乘
- replace：用function score替换query score
- 其它，例如：sum、avg、max、min

根据原始条件查询搜索文档，并且计算相关性算分，称为原始算分（query score）
根据过滤条件，过滤文档
符合过滤条件的文档，基于算分函数运算，得到函数算分（function score）
将原始算分（query score）和函数算分（function score）基于运算模式做运算，得到最终结果，作为相关性算分
过滤条件：决定哪些文档的算分被修改
算分函数：决定函数算分的算法
运算模式：决定最终算分结果

json

GET /hotel/_search
{
  "query": {
    "function_score": {
      "query": {
        "match": {
          "all": "外滩"
        }
      },
      "functions": [
        {
          "filter": {
            "term": {
              "name": "如家"
            }
          },
          "weight": 2
        }
      ],
      "boost_mode": "sum"
    }
  }
}

布尔查询

搜索时，参与打分的字段越多，查询的性能也越差。因此这种多条件查询时，建议这样做：

搜索框的关键字搜索，是全文检索查询，使用must查询，参与算分
其它过滤条件，采用filter查询。不参与算分

json

GET /hotel/_search
{
  "query": {
    "bool": {
      "must": [
        {
          "match": {
            "name": "如家"
          }
        }
      ],
      "must_not": [
        {
          "range": {
            "price": {
              "gte": 400
            }
          }
        }
      ],
      "filter": [
        {
          "geo_distance": {
            "distance": "100km",
            "location": {
              "lat": 31.73,
              "lon": 121.1
            }
          }
        }
      ]
    }
  }
}

搜索结果处理

排序

elasticsearch默认是根据相关度算分（_score）来排序，但是也支持自定义方式对搜索结果排序。可以排序字段类型有：keyword类型、数值类型、地理坐标类型、日期类型等

普通字段排序keyword、数值、日期类型排序的语法基本一致

json

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "price": {
        "order": "desc"
      },
      "starName": "asc"
    }
  ]
}

排序条件是一个数组，也就是可以写多个排序条件。按照声明的顺序，当第一个条件相等时，再按照第二个条件排序，以此类推

地理坐标排序

json

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "sort": [
    {
      "_geo_distance": {
        "location": "31,121",
        "unit": "km", 
        "order": "asc"
      }
    }
  ]
}

分页

elasticsearch 默认情况下只返回top10的数据。而如果要查询更多数据就需要修改分页参数了。elasticsearch中通过修改from、size参数来控制要返回的分页结果

from：从第几个文档开始
size：总共查询几个文档

json

GET /hotel/_search
{
  "query": {
    "match_all": {}
  },
  "from": 0,
  "size": 20
}

深度分页问题

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

search after：分页时需要排序，原理是从上一次的排序值开始，查询下一页数据。官方推荐使用的方式
scroll：原理将排序后的文档id形成快照，保存在内存。官方已经不推荐使用

分页查询的常见实现方案以及优缺点：
from + size：
优点：支持随机翻页
缺点：深度分页问题，默认查询上限（from + size）是10000
场景：百度、京东、谷歌、淘宝这样的随机翻页搜索
after search：
优点：没有查询上限（单次查询的size不超过10000）
缺点：只能向后逐页查询，不支持随机翻页
场景：没有随机翻页需求的搜索，例如手机向下滚动翻页
scroll：
优点：没有查询上限（单次查询的size不超过10000）
缺点：会有额外内存消耗，并且搜索结果是非实时的
场景：海量数据的获取和迁移。从ES7.1开始不推荐，建议用 after search方案

高亮

json

GET /hotel/_search
{
  "query": {
    "match": {
      "all": "如家"
    }
  },
  "highlight": {
    "fields": {
      "name": {
        "require_field_match": "false"		//字段匹配
      }
    }
  }
}

高亮是对关键字高亮，因此搜索条件必须带有关键字，而不能是范围这样的查询。
默认情况下，高亮的字段，必须与搜索指定的字段一致，否则无法高亮
如果要对非搜索字段高亮，则需要添加一个属性：required_field_match=false

RestClient查询文档

match,match_all查询

java

@Test
void matchAll() throws IOException {
    SearchRequest request = new SearchRequest( "hotel" );
    request.source().query( QueryBuilders.matchQuery( "all","如家" ) );
    SearchResponse search = client.search( request, RequestOptions.DEFAULT );
    this.jsonAnalysis( search );
}

结果解析

hits：命中的结果
total：总条数，其中的value是具体的总条数值
max_score：所有结果中得分最高的文档的相关性算分
hits：搜索结果的文档数组，其中的每个文档都是一个json对象
_source：文档中的原始数据，也是json对象
逐层解析JSON字符串
SearchHits：通过response.getHits()获取，就是JSON中的最外层的hits，代表命中的结果
SearchHits#getTotalHits().value：获取总条数信息
SearchHits#getHits()：获取SearchHit数组，也就是文档数组
SearchHit#getSourceAsString()：获取文档结果中的_source，也就是原始的json文档数据

java

void jsonParse( SearchResponse response ){
    SearchHits searchHits = response.getHits();
    //总记录数
    long total = searchHits.getTotalHits().value;
    System.out.println( "查询到:"+total+"条数据" );
    SearchHit[] hitsHits = searchHits.getHits();
    for ( SearchHit hit : hitsHits ) {
        //获取数据
        String json = hit.getSourceAsString();
        //反序列化流
        HotelDoc hotelDoc = JSON.parseObject( json, HotelDoc.class );

        //获取高亮数据
        Map<String, HighlightField> highlightFields = hit.getHighlightFields();
        if ( !CollectionUtils.isEmpty( highlightFields ) ) {

            //根据字段名获取高亮结果
            HighlightField field = highlightFields.get( "name" );
            if ( field != null ){
                String name = field.getFragments()[0].string();
                hotelDoc.setName( name );
            }

        }
        System.err.println( hotelDoc );
    }

}

精确查询

Java

@Test
void termSearch() throws IOException {
    SearchRequest request = new SearchRequest( INDEX_NAME );

    request.source().query( QueryBuilders.termQuery( "city","上海" ) );
    SearchResponse response = client.search( request, RequestOptions.DEFAULT );
    this.jsonParse( response );
}

@Test
void rangeSearch() throws IOException {
    SearchRequest request = new SearchRequest( INDEX_NAME );
    request.source().query(
        QueryBuilders.rangeQuery( "price" )
        .gte( 1000 ).lte( 2000 )
    );
    SearchResponse response = client.search( request, RequestOptions.DEFAULT );
    this.jsonParse( response );
}

复杂查询

java

@Test
void boolSearch() throws IOException {
    SearchRequest request = new SearchRequest( INDEX_NAME );
    request.source().query( QueryBuilders.boolQuery()
                           .must( QueryBuilders.termQuery( "city","上海" ) )
                           .filter( QueryBuilders.rangeQuery( "price" ).lte( 200 ) )
                          );
    SearchResponse search = client.search( request, RequestOptions.DEFAULT );
    this.jsonParse( search );
}

排序和分页

java

@Test
void pageQuery() throws IOException {
    int form = 3;
    int size = 10;

    SearchRequest request = new SearchRequest( "hotel" );
    //DSL
    request.source().query( QueryBuilders.matchAllQuery() );
    //排序
    request.source().sort( "price", SortOrder.ASC );
    //分页
    request.source().from( (form-1)*size ).size( size );
    SearchResponse search = client.search( request, RequestOptions.DEFAULT );
    this.jsonAnalysis( search );
}

高亮

java

@Test
void highlight() throws IOException {
    SearchRequest request = new SearchRequest( INDEX_NAME );
    request.source().query( QueryBuilders.matchQuery( "all","如家" ) )
        .highlighter( new HighlightBuilder()
                     .field( "name" )
                     //忽略字段匹配
                     .requireFieldMatch( false )
                    );
    SearchResponse search = client.search( request, RequestOptions.DEFAULT );
    System.out.println( search.getHits() );
}

json解析

java

//获取高亮数据
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
if ( !CollectionUtils.isEmpty( highlightFields ) ) {

    //根据字段名获取高亮结果
    HighlightField field = highlightFields.get( "name" );
    if ( field != null ){
        String name = field.getFragments()[0].string();
        hotelDoc.setName( name );
    }

}

数据聚合

**聚合（aggregations ）**可以让我们极其方便的实现对数据的统计、分析、运算,聚合常见的有三类

**桶（Bucket）**聚合：用来对文档做分组
- TermAggregation：按照文档字段值分组，例如按照品牌值分组、按照国家分组
- Date Histogram：按照日期阶梯分组，例如一周为一组，或者一月为一组
**度量（Metric）**聚合：用以计算一些值，比如：最大值、最小值、平均值等
- Avg：求平均值
- Max：求最大值
- Min：求最小值
- Stats：同时求max、min、avg、sum等
**管道（pipeline）**聚合：其它聚合的结果为基础做聚合

参加聚合的字段必须是keyword、日期、数值、布尔类型

Bucket聚合

json

GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAggs": {
      "terms": {
        "field": "brand",
        "size": 10,
        "order": {
          "_count": "asc"	//修改聚合的排序
        }
      }
    }
  }
}

限定聚合的范围

默认情况下，Bucket聚合是对索引库的所有文档做聚合，但真实场景下，用户会输入搜索条件，因此聚合必须是对搜索结果聚合。那么聚合必须添加限定条件，只要添加query条件即可

json

GET /hotel/_search
{
  "size": 0,
  "query": {
    "range": {
      "price": {
        "gte": 1000
      }
    }
  },
  "aggs": {
    "brandAggs": {
      "terms": {
        "field": "brand",
        "size": 10
      }
    }
  }
}

aggs代表聚合,与query同级,query限定聚合的范围
聚合三要素
名称
类型
字段
聚合可配置的属性
size 聚合结果数量
order 聚合结果排序方式
field 聚合字段

Metric聚合语法

json

GET /hotel/_search
{
  "size": 0,
  "aggs": {
    "brandAggs": {
      "terms": {
        "field": "brand",
        "size": 10,
        "order": {
          "avgAggs.avg": "asc"		//对聚合桶内的结果排序
        }
      },
      "aggs": {
        "avgAggs": {
          "stats": {
            "field": "score"
          }
        }
      }
    }
  }
}

RestAPI实现聚合

java

@Test
void bucketAggs() throws IOException {
    SearchRequest request = new SearchRequest( INDEX_NAME );
    //文档数量
    request.source().size( 0 )
        //限定聚合范围
        .query( QueryBuilders
               .rangeQuery( "price" )
               .gte( 1000 ) )
        //聚合
        .aggregation( AggregationBuilders
                     //桶名称
                     .terms( "brandAggs" )
                     //字段
                     .field("brand" )
                     .size(10)
                     //排序方式
                     .order( BucketOrder.count( true ) )
                    );

    SearchResponse response = client.search( request, RequestOptions.DEFAULT );

    this.jsonParse( response );
}

结果解析

java

void jsonParse( SearchResponse response ){
    Terms brandAggs = response.getAggregations().get( "brandAggs" );
    List<? extends Terms.Bucket> buckets = brandAggs.getBuckets();
    buckets.forEach( bucket -> System.err.println( bucket.getKeyAsString() ) );
}

Metric聚合

java

@Test
void metricAggs() throws IOException {
    SearchRequest request = new SearchRequest( INDEX_NAME );
    request.source().size( 0 ).aggregation( AggregationBuilders
            .terms( "brandAggs" )
            .size( 10 )
            .field("brand")
    );
    request.source().aggregation( AggregationBuilders
            .stats( "avgAggs" )
            .field( "score" )
    );
    SearchResponse response = client.search( request, RequestOptions.DEFAULT );
    this.jsonParse( response );
}

拼音分词器

要实现根据字母做补全，就必须对文档按照拼音分词,将下载好的压缩包解压上传到es的插件目录,重启后生效

自定义分词器

默认的拼音分词器会将每个汉字单独分为拼音，而我们希望的是每个词条形成一组拼音，需要对拼音分词器做个性化定制，形成自定义分词器,elasticsearch中分词器（analyzer）的组成包含三部分

character filters：在tokenizer之前对文本进行处理。例如删除字符、替换字符
tokenizer：将文本按照一定的规则切割成词条（term）。例如keyword，就是不分词；还有ik_smart
tokenizer filter：将tokenizer输出的词条做进一步处理。例如大小写转换、同义词处理、拼音处理等

声明自定义分词器的语法

json

PUT /test
{
  "settings": {
    "analysis": {
      "analyzer": {			// 自定义分词器
        "my_analyzer": {	// 分词器名称
          "tokenizer": "ik_max_word",
          "filter": "py"
        }
      },
      "filter": {			// 自定义tokenizer filter
        "py": {				// 过滤器名称
          "type":"pinyin",	// 过滤器类型，这里是pinyin
          "keep_full_pinyin": false,
          "keep_joined_full_pinyin": true,
          "keep_original": true,
          "limit_first_letter_length": 16,
          "remove_duplicated_term": true,
          "none_chinese_pinyin_tokenize": false
        
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "name": {
        "type": "text",
        "analyzer": "my_analyzer",
        "search_analyzer": "ik_smart"
      }
    }
  }
}

自动补全

elasticsearch提供了Completion Suggester查询来实现自动补全功能。这个查询会匹配以用户输入内容开头的词条并返回。为了提高补全查询的效率，对于文档中字段的类型有一些约束：

参与补全查询的字段必须是completion类型。
字段的内容一般是用来补全的多个词条形成的数组

查询DSL

json

GET /test2/_search
{
  "suggest": {
    "YOUR_SUGGESTION": {
      "text": "s",		//关键字
      "completion": {
        "field": "name", //补全字段
        "skip_duplicates": true, //跳过重复的
        "size": 10	//结果条数
      }
    }
  }
}

java

@Test
void suggest() throws IOException {
    SearchRequest request = new SearchRequest( "hotel" );
    request.source().suggest( new SuggestBuilder().addSuggestion(
        "suggestions",
            SuggestBuilders.completionSuggestion( "suggestion" )
                    .prefix( "上海" )
                    //是否跳过重复的
                    .skipDuplicates( true )
                    .size( 10 )
    ) );
    SearchResponse search = client.search( request, RequestOptions.DEFAULT );
    CompletionSuggestion suggestions = search.getSuggest().getSuggestion( "suggestions" );
    suggestions.getOptions().forEach( suggest->{
        System.out.println( suggest.getText().string() );
    } );
}

java

CompletionSuggestion suggestions = search.getSuggest().getSuggestion( "suggestions" );
suggestions.getOptions().forEach( suggest->{
    System.out.println( suggest.getText().string() );
} );

数据同步

方式一：同步调用

优点：实现简单，粗暴
缺点：业务耦合度高

优点：低耦合，实现难度一般
缺点：依赖mq的可靠性

方式三：监听binlog

优点：完全解除服务间耦合
缺点：开启binlog增加数据库负担、实现复杂度高

集群

单机的elasticsearch做数据存储，必然面临两个问题

集群搭建

编写docker-compose文件,并运行

version: '2.2'
services:
  es01:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.17.7
    container_name: es01
    environment:
      - node.name=es01
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es02,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - data01:/usr/share/elasticsearch/data
    ports:
      - 9200:9200
    networks:
      - elastic
  es02:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.17.7
    container_name: es02
    environment:
      - node.name=es02
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es01,es03
      - cluster.initial_master_nodes=es01,es02,es03
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - data02:/usr/share/elasticsearch/data
    networks:
      - elastic
  es03:
    image: docker.elastic.co/elasticsearch/elasticsearch:7.17.7
    container_name: es03
    environment:
      - node.name=es03
      - cluster.name=es-docker-cluster
      - discovery.seed_hosts=es01,es02
      - cluster.initial_master_nodes=es01,es02,es03
      - bootstrap.memory_lock=true
      - "ES_JAVA_OPTS=-Xms512m -Xmx512m"
    ulimits:
      memlock:
        soft: -1
        hard: -1
    volumes:
      - data03:/usr/share/elasticsearch/data
    networks:
      - elastic

volumes:
  data01:
    driver: local
  data02:
    driver: local
  data03:
    driver: local

networks:
  elastic:
    driver: bridge

es中集群节点的职责划分

节点类型	配置参数	默认值	节点职责
master eligible	node.master	true	备选主节点：主节点可以管理和记录集群状态、决定分片在哪个节点、处理创建和删除索引库的请求
data	node.data	true	数据节点：存储数据、搜索、聚合、CRUD
ingest	node.ingest	true	数据存储之前的预处理
coordinating	上面3个参数都为false则为coordinating节点	无	路由请求到其它节点合并其它节点处理的结果，返回给用户

脑裂

在一个集群中，主节点与其它节点失联,此时，node2和node3认为node1宕机，就会重新选主,当node3当选后，集群继续对外提供服务，node2和node3自成集群，node1自成集群，两个集群数据不同步，出现数据差异。当网络恢复后，因为集群中有两个master节点，集群状态的不一致，出现脑裂的情况：

分布式存储

分布式查询

故障转移

ElasticSearch ​

elasticsearch,kibana安装 ​

分词器 ​

安装分词器 ​

索引库操作 ​

文档操作 ​

RestAPI ​

初始化RestClient ​

索引库操作 ​

文档操作 ​

查询文档 ​

分类查询 ​

全文检索查询 ​

精确查询 ​

地理坐标查询 ​

复合查询 ​

function score 查询 ​

布尔查询 ​

搜索结果处理 ​

RestClient查询文档 ​

数据聚合 ​

Bucket聚合 ​

Metric聚合语法 ​

RestAPI实现聚合 ​

拼音分词器 ​

数据同步 ​

集群 ​

集群搭建 ​

ElasticSearch

elasticsearch,kibana安装

分词器

安装分词器

索引库操作

文档操作

RestAPI

初始化RestClient

索引库操作

文档操作

查询文档

分类查询

全文检索查询

精确查询

地理坐标查询

复合查询

function score 查询

布尔查询

搜索结果处理

RestClient查询文档

数据聚合

Bucket聚合

Metric聚合语法

RestAPI实现聚合

拼音分词器

数据同步

集群

集群搭建