ElasticSearch-实战

淩亂°似流年 2021-11-27 07:12 332阅读 0赞

版本说明：

Windows 10 专业版

elasticsearch-7.1.1（Windows X64）

spring-boot 2.1.3.RELEASE

PostmanCanary-7.3.5

相关单元测试代码：[https://github.com/o99o/SpringBoot\_ElasticSearch.git][https_github.com_o99o_SpringBoot_ElasticSearch.git]

## 1 ElasticSearch 介绍 ##

### 1.1 介绍 ###

ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。\[来源于百度百科\]  
官方网址：https://www.elastic.co/cn/products/elasticsearch  
文档地址：https://www.elastic.co/guide/en/elasticsearch/reference/index.html  
Github ：https://github.com/elastic/elasticsearch  
归结为两点：elasticsearch是一个基于Lucene的高扩展的分布式搜索服务器，支持开箱即用；elasticsearch隐藏了Lucene的复杂性，对外提供Restful 接口来操作索引、搜索。  
突出优点：扩展性好，可部署上百台服务器集群，处理PB级数据；近实时的去索引数据、搜索数据。

### 1.2 原理与应用 ###

1.2.1索引结构

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70][]

ES的索引采用的是倒排索引的方式，除了存文档之外还存储了分词数据集，每个词都会记录与之关联的文档。在检索的时候就很方便的通过词来找到对应的文档。

**1.2.2 RESTful应用方法**

Elasticsearch 使用的是标准的 RESTful 风格的 API 和 JSON。此外，还构建和维护了很多其他语言的客户端，例如 Java、Python、.NET、SQL 和 PHP以及其他社区客户端。这些客户端使用起来简单自然，而且就像 Elasticsearch 一样，不会对您的使用方式进行限制。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 1][]

## 2 ElasticaSearch 安装 ##

### 2.1 安装 ###

安装配置：  
1、新版本要求至少jdk1.8以上。  
2、支持tar、zip、rpm等多种安装方式。  
在windows下开发建议使用ZIP安装方式。  
3、支持docker方式安装

详细参见：[https://www.elastic.co/guide/en/elasticsearch/reference/current/install-elasticsearch.html][https_www.elastic.co_guide_en_elasticsearch_reference_current_install-elasticsearch.html]

下载并解压 ES：elasticsearch-7.1.1

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 2][]

**2.2 配置文件  
2.2.1 三个配置文件**

ES的配置文件的地址根据安装形式的不同而不同：使用zip、tar安装，配置文件的地址在安装目录的config下；使用RPM安装，配置文件在/etc/elasticsearch下；使用MSI安装，配置文件的地址在安装目录的config下，并且会自动将config目录地址写入环境变量ES\_PATH\_CONF。  
配置文件如下：

elasticsearch.yml ： 用于配置Elasticsearch运行参数  
    jvm.options ： 用于配置Elasticsearch JVM设置  
    log4j2.properties： 用于配置Elasticsearch日志

**2.2.2 elasticsearch.yml**

配置格式是YAML，可以采用如下两种方式：

方式1：层次方式  
    path: data: /var/lib/elasticsearch logs: /var/log/elasticsearch  
    方式2：属性方式  
    path.data: /var/lib/elasticsearch path.logs: /var/log/elasticsearch

#集群名称
    cluster.name: es-cluster
    #节点名称
    node.name: es_node_1
    #给节点添加额外属性，暂时没用
    node.attr.rack: r1
    #数据存储位置
    path.data: D:\o99o\Elasticsearch\elasticsearch-7.1.1_cluster_node1\data
    #日志存储位置
    path.logs: D:\o99o\Elasticsearch\elasticsearch-7.1.1_cluster_node1\logs
    #网络绑定,这里我绑定 0.0.0.0,支持外网访问
    network.host: 127.0.0.1
    #对外服务http端口，默认9200
    #http.port: 9200
    #单播节点列表
    #discovery.seed_hosts: ["127.0.0.1:9300","127.0.0.1:9301","127.0.0.1:9302"]
    #手动指定可以成为mater的所有节点的name或者ip，这些配置将会在第一次选举中进行计算
    #cluster.initial_master_nodes: ["127.0.0.1:9300"]
    #控制集群在达到多少个节点之后才会开始数据恢复,通过这个设置可以避免集群自动相互发现的初期,
    #shard分片不全的问题,假如es集群内一共有5个节点,就可以设置为5,
    #那么这个集群必须有5个节点启动后才会开始数据分片,如果设置为3,
    #就有可能另外两个节点没存储数据分片
    #gateway.recover_after_nodes: 3
    #删除索引时给出索引名
    #action.destructive_requires_name: true
    #集群节点之间通信端口
    #transport.tcp.port: 9300
    #是否可以成为master节点
    #node.master: true
    #是否允许该节点存储数据,默认开启
    #node.data: true
    #用来在真正对文档进行索引之前做预处理
    #如移除某个字段，重命名某个字段等
    #node.ingest: true
    #设置一台服务器能运行的节点数
    #node.max_local_storage_nodes: 3
    # 安装head插件时的必要参数:
    #http.cors.enabled: true
    #http.cors.allow-origin: "*"
    #允许跨域访问头部信息
    #http.cors.allow-headers: "X-Requested-With,Content-Type, Content-Length, Authorization"
    
    xpack.ml.enabled: false

**2.2.3 jvm.options**

在jvm.options中设置最小及最大的JVM堆内存大小：-Xms、-Xmx 建议两个值设置为相等且不超过物理内存的一半。

**2.2.4 log4j2.properties**

日志文件设置，ES使用log4j，采用默认配置即可，可以更具不同环境需要修改日志级别的配置。

**2.2.5 系统配置（linux）**

在linux上根据系统资源情况，可将每个进程最多允许打开的文件数设置大些。

#查询当前文件数
    su limit -n 
    #设置limit的值
    sudo ulimit ‐n 65536

也可以通过修改 /etc/security/limits.conf 添加`elasticsearch ‐ nofile 65536` 进行持久设置。

### 2.3 启动ES ###

进入bin目录，在cmd下运行：elasticsearch.bat  
浏览器输入：[http://localhost:9200][http_localhost_9200]  
显示结果如下（配置不同内容则不同）说明 ES启动成功：

{
        "name": "DESKTOP-0A0HUGR",
        "cluster_name": "elasticsearch",
        "cluster_uuid": "0uwGptWERcOecKF6fHXjrw",
        "version": {
            "number": "7.1.1",
            "build_flavor": "default",
            "build_type": "zip",
            "build_hash": "7a013de",
            "build_date": "2019-05-23T14:04:00.380842Z",
            "build_snapshot": false,
            "lucene_version": "8.0.0",
            "minimum_wire_compatibility_version": "6.8.0",
            "minimum_index_compatibility_version": "6.0.0-beta1"
        },
        "tagline": "You Know, for Search"
    }

### 2.4 head 插件安装 ###

head插件是ES的一个可视化管理插件，用来监视ES的状态，并通过head客户端和ES服务进行交互，比如创建映射、创建索引等，head的项目地址在https://github.com/mobz/elasticsearch-head 。

安装教程见：[https://blog.csdn.net/taotao\_guiwang/article/details/98849857][https_blog.csdn.net_taotao_guiwang_article_details_98849857]

## 3 ES 快速入门 ##

ES作为一个索引及搜索服务，对外提供丰富的REST接口，新使用几个快速入门的实例对ES的使用方法及流程有个初步的认识。

3.1 创建索引库

ES的索引库是一个逻辑概念，它包括了分词列表及文档列表，同一个索引库中存储了相同类型的文档。它就相当于MySQL中的表，或相当于Mongodb中的集合。关于索引这个语：

索引（名词）：ES是基于Lucene构建的一个搜索服务，它要从索引库搜索符合条件索引数据。  
    索引（动词）：索引库刚创建起来是空的，将数据添加到索引库的过程称为索引。

下边介绍两种创建索引库的方法，它们的工作原理是相同的，都是客户端向ES服务发送命令。  
put [http://localhost:9200/索引库名称][http_localhost_9200 1]

{
      "settings":{
      "index":{
          "number_of_shards":1,
          "number_of_replicas":0
       }    
      }
    }

number\_of\_shards：设置分片的数量，在集群中通常设置多个分片，表示一个索引库将拆分成多片分别存储不同的结点，提高了ES的处理能力和高可用性，入门程序使用单机环境，这里设置为1。  
number\_of\_replicas：设置副本的数量，设置副本是为了提高ES的高可靠性，单机环境设置为0.  
如下是创建的例子，创建es\_index索引库，共1个分片，0个副本：  
![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 3][]

### 3.2 创建映射 ###

**3.2.1 概念说明**

在索引中每个文档都包括了一个或多个field，创建映射就是向索引库中创建field的过程，下边是document和field与关系数据库的概念的类比：  
文档（Document） —— Row记录  
字段（Field） —— Columns 列  
注意：6.0之前的版本有type（类型）概念，type相当于关系数据库的表，ES官方将在ES9.0版本中彻底删除type。  
上边讲的创建索引库相当于关系数据库中的数据库还是表？

如果相当于数据库就表示一个索引库可以创建很多不同类型的文档，这在ES中也是允许的。  
    如果相当于表就表示一个索引库只能存储相同类型的文档，ES官方建议 在一个索引库中只存储相同类型的文档。  
**3.2.2 创建映射**

请求命令如下：  
post http://localhost:9200/索引库名称 /类型名称（当前版本不支持）/\_mapping  
创建类型为es\_index的映射，共包括两个字段：name、description  
post 请求：http://localhost:9200/es\_index/\_mapping

{
      "properties": {   
               "name": {
                  "type": "text"
               },
               "description": {
                  "type": "text"
               }
            }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 4][]

**3.3 创建文档**

ES中的文档相当于MySQL数据库表中的记录。  
请求方式：POST或PUT （如果不指定id值ES会自动生成ID） http://localhost:9200/es\_index/id  
http://localhost:9200/es\_index/6666

{
      "name":"全文检索-Elasticearch",
      "description":"Elasticsearch是一个实时的分布式搜索和分析引擎。它可以帮助你用前所未有的速度去处理大规模数据。它可以用于全文搜索，结构化搜索以及分析，当然你也可以将这三者进行组合。"
    }

**注意： 添加数据时使用默认type：\_doc**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 5][]

** 3.4 搜索文档**

1、根据id查询文档  
请求方式：GET [http://localhost:9200/es\_index/\_doc/666][http_localhost_9200_es_index_doc_666]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 6][]

2、查询名称中包括 “全文” 的的记录  
请求方式：GET [http://localhost:9200/es\_index/\_doc/\_search?q=name:全文][http_localhost_9200_es_index_doc_search_q_name]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 7][]

** 3.4.1查询结果分析**

{
        "took": 29,
        "timed_out": false,
        "_shards": {
            "total": 1,
            "successful": 1,
            "skipped": 0,
            "failed": 0
        },
        "hits": {
            "total": {
                "value": 2,
                "relation": "eq"
            },
            "max_score": 0.36464313,
            "hits": [
                {
                    "_index": "es_index",
                    "_type": "_doc",
                    "_id": "Bvf5ImwBnW28_aAiSlCX",
                    "_score": 0.36464313,
                    "_source": {
                        "name": "全文检索-Elasticearch",
                        "description": "Elasticsearch是一个实时的分布式搜索和分析引擎。它可以帮助你用前所未有的速度去处理大规模数据。它可以用于全文搜索，结构化搜索以及分析，当然你也可以将这三者进行组合。"
                    }
                },

*  took：本次操作花费的时间，单位为毫秒。
 *  timed\_out：请求是否超时
 *  \_shards：说明本次操作共搜索了哪些分片
 *  hits：搜索命中的记录
 *  \_score：每个文档都有一个匹配度得分，按照降序排列。
 *  \_source：显示了文档的原始内容

## 4 IK 分词器 ##

**4.1 测试分词器**

在添加文档时会进行分词，索引中存放的就是一个一个的词（term），当你去搜索时就是拿关键字去匹配词，最终找到词关联的文档。  
测试当前索引库使用的默认分词器：

请求方式POST ： [http://localhost:9200/\_analyze][http_localhost_9200_analyze]

{"text":"测试分词器"}

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 8][]

当前索引库使用的默认分词器对中文就是单字分词。

### 4.2 安装IK分词器 ###

使用IK分词器可以实现对中文分词的效果。  
下载IK分词器：（Github地址：[https://github.com/medcl/elasticsearch-analysis-ik/releases][https_github.com_medcl_elasticsearch-analysis-ik_releases][）][Link 1]  
解压，并将解压的文件拷贝到ES安装目录的plugins下的ik目录下

**注意：版本要和ES版本一致**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 9][]

指定IK分词，再次测试分词效果

{"text":"测试分词器","analyzer":"ik_max_word" }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 10][]

### 4.3 两种分词模式 ###

ik分词器有两种分词模式：ik\_max\_word和ik\_smart模式。

*  ik\_max\_word 会将文本做最细粒度的拆分

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 11][]

*  ** ik\_smart 会做最粗粒度的拆分**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 12][]

** 4.4 自定义词库**

如果要让分词器支持一些专有词语，可以自定义词库。iK分词器自带一个main.dic的文件，在插件的config目录中。我们可以在上边的目录中新建一个自定义的词库文件（注意文件格式为utf-8（不要选择utf-8 BOM）），然后可以在  
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"></entry>
    	 
    	<entry key="ext_stopwords"></entry>
    	
    	
    	
    	
    </properties>

## 5 映射 ##

上边章节安装了ik分词器，如果在索引和搜索时去使用ik分词器呢？如何指定其它类型的field，比如日期类型、数值类型等。  
本章节学习各种映射类型及映射维护方法。

### 5.1 映射维护方法 ###

1、查询所有索引的映射：  
GET： [http://localhost:9200/\_mapping][http_localhost_9200_mapping]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 13][]

2、创建映射  
post 请求：[http://localhost:9200/es\_index/\_mapping][http_localhost_9200_es_index_mapping]

{
      "properties": {   
               "name": {
                  "type": "text"
               },
               "description": {
                  "type": "text"
               },
               "type": {
                  "type": "keyword"
               }
            }
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 14][]

3、更新映射  
映射创建成功可以添加新字段，已有字段不允许更新。

4、删除映射  
通过删除索引来删除映射。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 15][]

### 5.2 常用映射类型 ###

**5.2.1 text文本字段**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 16][]

字符串包括 text和keyword两种类型。text类型的可以设置的属性如下：

*  1）analyzer属性指定分词器。

如指定name的字段类型为text，使用ik分词器的ik\_max\_word分词模式。对于ik分词器建议是索引时使用ik\_max\_word将搜索内容进行细粒度分词，搜索时使用ik\_smart提高搜索精确性。

"name":{
            "type":"text",
            "analyzer":"ik_max_word",
            "search_analyzer":"ik_smart"
        }

*  2）index 属性指定是否索引。

默认为index=true，即要进行索引，只有进行索引才可以从索引库搜索到。  
但是也有一些内容不需要索引，比如：商品图片地址只被用来展示图片，不进行搜索图片，此时可以将index设置为false。

"logo":{
            "type":"text",
            "index":false
        }

*  3）store

是否在source之外存储，每个文档索引后会在 ES中保存一份原始文档，存放在"\_source"中，一般情况下不需要设置store为true，因为在\_source中已经有一份原始文档了。

**5.2.2 keyword关键字字段**

上边介绍的 text文本字段在映射时要设置分词器，keyword字段为关键字字段，通常搜索keyword是按照整体搜索，所以创建keyword字段的索引时是不进行分词的，比如：邮政编码、手机号码、身份证等。keyword字段通常用于过虑、排序、聚合等。

"mobile":{
            "type":"keyword"
        }

**5.2.3 date日期类型**

日期类型不用设置分词器，通常用于排序。

*  1)format 设置日期格式  
    设置允许date字段存储年月日时分秒、年月日及毫秒三种格式。

{
        "timestamp":{
            "type":"date",
            "format":"yyyy‐MM‐dd HH:mm:ss || yyyy‐MM‐dd"
        }
    }

**5.2.4 数值类型**

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 17][]

原则：尽量选择范围小的类型，提高搜索效率；对于浮点数尽量用比例因子，比如一个价格字段，单位为元，我们将比例因子设置为100这在ES中会将你传入的数值乘100后存储，映射如下：

{
        "price":{
            "type":"scaled_float",
            "scaling_factor":100
        }
    }

如果输入的价格是23.456，ES会将23.456乘以100再取一个接近原始值的数，得出2346。使用比例因子的好处是整型比浮点型更易压缩，节省磁盘空间。如果比例因子不适合，则从下表选择范围小的去用：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 18][]

**6 索引管理  
6.1 搭建工程  
6.1.1 ES客户端**

ES提供多种不同的客户端：  
1、TransportClient ES提供的传统客户端，官方计划8.0版本删除此客户端。  
2、RestClient 是官方推荐使用的，它包括两种：Java Low Level REST Client和 Java High Level REST Client。ES在6.0之后提供 Java High Level REST Client， 两种客户端官方更推荐使用 Java High Level REST Client，不过当  
前它还处于完善中，有些功能还没有。本文准备采用 Java High Level REST Client，如果它有不支持的功能，则使用Java Low Level REST Client。

**6.1.2 创建搜索（Springboot）工程**

1.添加依赖

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

2.配置文件 application.properties

# 端口
    server.port=8888
    # 程序名称
    spring.application.name=es-search-service
    #多个结点中间用逗号分隔
    elasticsearch.hostlist=${eshostlist:127.0.0.1:9200}

3.配置类ElasticsearchConfig

package com.zit.es.config;
    
    import org.apache.http.HttpHost;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.springframework.beans.factory.annotation.Value;
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    public class ElasticsearchConfig {
    	@Value("${elasticsearch.hostlist}")
    	private String hostlist;
    
    	@Bean
    	public RestHighLevelClient restHighLevelClient() {
    		// 解析hostlist配置信息
    		String[] spilt = hostlist.split(",");
    		// 创建HttpHost数组，其中存放主机和端口的配置信息
    		HttpHost[] httpHostArray = new HttpHost[spilt.length];
    		for(int i=0;i<spilt.length;++i) {
    			String item = spilt[i];
    			httpHostArray[i] = new HttpHost(item.split(":")[0], Integer.parseInt(item.split(":")[1]), "http");
    		}
    		
    		// 创建RestHighLevelClient客户端
    		return new RestHighLevelClient(RestClient.builder(httpHostArray));
    	}
    	
    	// 项目主要使用RestHighLevelClient，对于低级客户端暂时不用
    	@Bean
    	public RestClient restClient() {
    		// 解析hostlist配置信息
    		String[] spilt = hostlist.split(",");
    		// 创建HttpPost数组，存放es主机和端口的配置信息
    		HttpHost[] httpHostArray = new HttpHost[spilt.length];
    		for(int i=0;i<spilt.length;++i) {
    			String item = spilt[i];
    			httpHostArray[i] = new HttpHost(item.split(":")[0],
    					Integer.parseInt(item.split(":")[1]),"http");
    		}
    		return RestClient.builder(httpHostArray).build();
    	}
    	
    }

### 6.2 创建索引库 ###

**6.2.1 API**

创建索引： put [http://localhost:9200/es\_index][http_localhost_9200_es_index]

{
      "settings":{
      "index":{
          "number_of_shards":1,
          "number_of_replicas":0
       }    
      }
    }

创建映射： put [http://localhost:9200/es\_index][http_localhost_9200 1]/\_mapping

{
    	"properties": {
    		"name": {
    			"type": "text",
    			"analyzer": "ik_max_word",
    			"search_analyzer": "ik_smart"
    		},
    		"description": {
    			"type": "text",
    			"analyzer": "ik_max_word",
    			"search_analyzer": "ik_smart"
    		},
    		"studymodel": {
    			"type": "keyword"
    		},
    		"price": {
    			"type": "float"
    		},
    		"timestamp": {
    			"type": "date",
    			"format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
    		}
    	}
    }

**6.2.2 Java Client**

package com.zit.es;
    
    import java.io.IOException;
    
    import org.elasticsearch.client.IndicesClient;
    import org.elasticsearch.client.RequestOptions;
    import org.elasticsearch.client.RestClient;
    import org.elasticsearch.client.RestHighLevelClient;
    import org.elasticsearch.client.indices.CreateIndexRequest;
    import org.elasticsearch.client.indices.CreateIndexResponse;
    import org.elasticsearch.common.settings.Settings;
    import org.elasticsearch.common.xcontent.XContentType;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @SpringBootTest
    @RunWith(SpringRunner.class)
    public class SpringBootElasticSearchApplicationTests {
    	
    	@Autowired
    	RestHighLevelClient highLevelClient;
    	
    	@Autowired
    	RestClient restClient;
    
    	@Test
    	public void testCreateIndex() throws IOException{
    		// 创建索引请求对象，并设置索引名称
    		CreateIndexRequest createIndexRequest = new CreateIndexRequest("es_index");
    		// 设置索引参数
    		createIndexRequest.settings(Settings.builder().put("number_of_shards",1).
    				put("number_of_replicas",0));
    		// 设置映射
    		createIndexRequest.mapping("{\n" +
    	                " \t\"properties\": {\n" +
    	                "           \"name\": {\n" +
    	                "              \"type\": \"text\",\n" +
    	                "              \"analyzer\":\"ik_max_word\",\n" +
    	                "              \"search_analyzer\":\"ik_smart\"\n" +
    	                "           },\n" +
    	                "           \"description\": {\n" +
    	                "              \"type\": \"text\",\n" +
    	                "              \"analyzer\":\"ik_max_word\",\n" +
    	                "              \"search_analyzer\":\"ik_smart\"\n" +
    	                "           },\n" +
    	                "           \"studymodel\": {\n" +
    	                "              \"type\": \"keyword\"\n" +
    	                "           },\n" +
    	                "           \"price\": {\n" +
    	                "              \"type\": \"float\"\n" +
    	                "           }\n" +
    	                "        }\n" +
    	                "}", XContentType.JSON);
    		 // 创建索引操作客户端
    		 IndicesClient indices = highLevelClient.indices();
    		 // 创建响应对象
    		 CreateIndexResponse createIndexResponse = indices.create(createIndexRequest, RequestOptions.DEFAULT);
    		 // 得到响应结果
    		 boolean acknowledged = createIndexResponse.isAcknowledged();
    		 System.out.println(acknowledged);
    	}
    	
    	// 删除索引库
    	/*
    	 * @Test public void testDeleteIndex() throws IOException{ // 删除索引请求对象
    	 * DeleteIndexRequest deleteIndexRequest = new DeleteIndexRequest("es_index");
    	 * /// 删除索引 // 创建索引操作客户端 IndicesClient indices = highLevelClient.indices();
    	 * AcknowledgedResponse acknowledgedResponse =
    	 * indices.delete(deleteIndexRequest, RequestOptions.DEFAULT); // 得到响应结果 boolean
    	 * acknowledged = acknowledgedResponse.isAcknowledged();
    	 * System.out.println(acknowledged); }
    	 */
    
    }

**6.3 添加文档**

@Test
    	public void testAddDoc() throws IOException{
    		// 准备数据
    		Map<String, Object> jsonMap = new HashMap<>();
    		jsonMap.put("name", "Spring Cloud");
    		jsonMap.put("description", "注册中心Nacos");
    		jsonMap.put("studymodel", "20190725");
    		jsonMap.put("price", 5.6f);
    		// 索引请求对象
    		IndexRequest indexRequest = new IndexRequest("es_index");
    		// 指定索引文档内容
    		indexRequest.source(jsonMap);
    		// 索引响应对象
    		IndexResponse indexResponse = highLevelClient.index(indexRequest, RequestOptions.DEFAULT);
    		// 获取响应结果
    		DocWriteResponse.Result result = indexResponse.getResult();
    		System.out.println(result);
    	}

### 6.4 查询文档 ###

@Test
    	public void getDoc() throws IOException{
    		GetRequest getRequest = new GetRequest("es_index","_doc","ruZCJ2wB7dcg4IHXgfGu");
    		GetResponse getResponse = highLevelClient.get(getRequest, RequestOptions.DEFAULT);
    		boolean exists = getResponse.isExists();
    		if (exists) {
    			Map<String, Object> sourceAsMap =  getResponse.getSourceAsMap();
    			System.out.println(sourceAsMap);
    		}else {
    			System.out.println("未找到。");
    		}
    	}

### 6.5 更新文档 ###

ES更新文档的顺序是：先检索到文档、将原来的文档标记为删除、创建新文档、删除旧文档，创建新文档就会重建索引。

// 更新文档
    	@Test
    	public void updateDoc() throws IOException{
    		UpdateRequest updateRequest = 
    				new UpdateRequest("es_index","_doc","ruZCJ2wB7dcg4IHXgfGu");
    		Map<String, Object> map = new HashMap<>();
    		map.put("name", "Spring Cloud 实战");
    		updateRequest.doc(map);
    		UpdateResponse update = highLevelClient.update(updateRequest, RequestOptions.DEFAULT);
    		RestStatus status = update.status();
    		System.out.println(status);
    	}

### 6.6 删除文档 ###

// 删除文档
    	// 根据id删除文档
    	@Test
    	public void testDelDoc() throws IOException{
    		// 删除文档id
    		String id = "ruZCJ2wB7dcg4IHXgfGu";
    		// 删除索引请求对象
    		DeleteRequest deleteRequest = new DeleteRequest("es_index","_doc","ruZCJ2wB7dcg4IHXgfGu");
    		// 响应对象
    		DeleteResponse deleteResponse = highLevelClient.delete(deleteRequest, RequestOptions.DEFAULT);
    		// 获取响应结果
    		DocWriteResponse.Result result = deleteResponse.getResult();
    		System.out.println(result);
    	}

## 7 搜索管理 ##

### 7.1 准备环境 ###

7.1.1 创建映射  
创建es\_index索引库。  
创建如下映射  
POST: [http://localhost:9200/es\_index/\_mapping][http_localhost_9200_es_index_mapping 1]

{
        "properties":{
            "description":{
                "type":"text",
                "analyzer":"ik_max_word",
                "search_analyzer":"ik_smart"
            },
            "name":{
                "type":"text",
                "analyzer":"ik_max_word",
                "search_analyzer":"ik_smart"
            },
            "logo":{
                "type":"text",
                "index":false
            },
            "price":{
                "type":"float"
            },
            "studymodel":{
                "type":"keyword"
            },
            "timestamp":{
                "type":"date",
                "format":"yyyy‐MM‐dd HH:mm:ss||yyyy‐MM‐dd||epoch_millis"
            }
        }
    }

**7.1.2 插入测试数据**

http://localhost:9200/es_index/_doc/1
    {
    "name": "Springboot",
    "description": "Spring Boot是由Pivotal团队提供的全新框架，其设计目的是用来简化新Spring应用的初始搭建以及开发过程。",
    "studymodel": "201002",
    "price":38.6,
    "timestamp":"2019‐06‐15 14:11:35",
    "pic":"springboot.jpg"
    }
    
    http://localhost:9200/es_index/_doc/2
    {
    "name": "spring基础",
    "description": "spring 在java领域非常流行，java程序员都在用。",
    "studymodel": "201001",
    "price":88.6,
    "timestamp":"2019‐06‐15 14:11:35",
    "pic":"spring.jpg"
    }
    
    http://localhost:9200/es_index/_doc/3
    {
    "name": "elasticsearch",
    "description": "ElasticSearch是一个基于Lucene的搜索服务器。它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。",
    "studymodel": "201001",
    "price":99.9,
    "timestamp":"2019‐06‐15 14:11:35",
    "pic":"elasticsearch.png"
    }

**7.1.3 简单搜索**

简单搜索就是通过url进行查询，以get方式请求ES。  
格式：get …/\_search?q=…  
q：搜索字符串。  
?q=name:spring 搜索name中包括spring的文档。

**7.2.1 查询所有文档**

查询所有索引库的文档。  
GET [http://localhost:9200/\_search][http_localhost_9200_search]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 19][]

查询指定索引库指定类型下的文档.  
GET [http://localhost:9200/es\_index/\_doc/\_search][http_localhost_9200_es_index_doc_search]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 20][]

POST [http://localhost:9200/es\_index/\_doc/\_search][http_localhost_9200_es_index_doc_search]

{
        "query":{
            "match_all":{
    
            }
        },
        "_source":[
            "name",
            "studymodel"
        ]
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 21][]

\_source：source源过虑设置，指定结果中所包括的字段有哪些。

// 搜索type下所有记录
    	@Test
    	public void testSearchAll() throws IOException{
    		SearchRequest searchRequest = new SearchRequest("es_index");
    		SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    		searchSourceBuilder.query(QueryBuilders.matchAllQuery());
    		// source源字段过滤
    		searchSourceBuilder.fetchSource(new String[]{"name","studymodel"},new String[]{});
    		searchRequest.source(searchSourceBuilder);
    		SearchResponse searchResponse = highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    		SearchHits hits = searchResponse.getHits();
    		SearchHit[] searchHits = hits.getHits();
    		for(SearchHit hit:searchHits) {
    			String index = hit.getIndex();
    			float score = hit.getScore();
    			String sourceAString = hit.getSourceAsString();
    			Map<String, Object> sourceASMap = hit.getSourceAsMap();
    			String name = (String) sourceASMap.get("name");
    			String studymodel = (String) sourceASMap.get("studymodel");
    			System.out.println(name);
    			System.out.println(studymodel);
    		}
    	}

**7.2.2 分页查询**

ES支持分页查询，传入两个参数：from和size。  
form：表示起始文档的下标，从0开始。  
size：查询的文档数量。  
POST [http://localhost:9200/es\_index/\_doc/\_search][http_localhost_9200_es_index_doc_search]

{
        "from":0,
        "size":1,
        "query":{
            "match_all":{
    
            }
        },
        "_source":[
            "name",
            "studymodel"
        ]
    }

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 22][]

@Test
    	public void pageQuery() throws IOException {
    		SearchRequest searchRequest = new SearchRequest("es_index");
    		SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    		searchSourceBuilder.query(QueryBuilders.matchAllQuery());
    		// 分页查询，设置起始下标，从0开始
    		searchSourceBuilder.from(0);
    		// 每页显示个数
    		searchSourceBuilder.size(10);
    		// source源字段过滤
    		searchSourceBuilder.fetchSource(new String[] {"name","studymodel"},new String[] {});
    		searchRequest.source(searchSourceBuilder);
    		SearchResponse searchResponse =highLevelClient.search(searchRequest, RequestOptions.DEFAULT);
    		SearchHits hits = searchResponse.getHits();
    		SearchHit[] searchHits = hits.getHits();
    		for(SearchHit hit:searchHits) {
    			String index = hit.getIndex();
    			float score = hit.getScore();
    			String sourceAString = hit.getSourceAsString();
    			Map<String, Object> sourceASMap = hit.getSourceAsMap();
    			String name = (String) sourceASMap.get("name");
    			String studymodel = (String) sourceASMap.get("studymodel");
    			System.out.println(name);
    			System.out.println(studymodel);
    		}
    	}

**7.2.3 Term Query**

Term Query为精确查询，在搜索时会整体匹配关键字，不再将关键字分词。

POST [http://localhost:9200/es\_index/\_doc/\_search][http_localhost_9200_es_index_doc_search]

{
        "query":{
            "term":{
    			"name":"springboot"
            }
        },
        "_source":[
            "name",
            "studymodel"
        ]
    }

SearchRequest searchRequest = new SearchRequest("es_index"); 
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    searchSourceBuilder.query(QueryBuilders.termQuery("name","springboot"));
    //source源字段过虑
    searchSourceBuilder.fetchSource(new String[]{"name","studymodel"}, new String[]{});
    searchRequest.source(searchSourceBuilder);
    SearchResponse searchResponse = client.search(searchRequest);

**7.2.4 根据id精确匹配**

ES提供根据多个id值匹配的方法：  
POST [http://localhost:9200/es\_index/\_doc/\_search][http_localhost_9200_es_index_doc_search]

{
        "query":{
            "ids":{
    			"type":"_doc",
    			"values":["2","3","4"]
            }
        }
    }

SearchRequest searchRequest = new SearchRequest("es_index"); 
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    String[] split = new String[]{"2","3","4"}; 
    List<String> idList = Arrays.asList(split);
    searchSourceBuilder.query(QueryBuilders.termsQuery("_id", idList));

**7.2.5 match Query**

1、基本使用  
match Query即全文检索，它的搜索方式是先将搜索字符串分词，再使用各各词条从索引中搜索。  
match query与Term query区别是match query在搜索前先将搜索关键字分词，再拿各各词语去索引中搜索。  
POST http://localhost:9200/es\_index/\_doc/\_search

{
        "query":{
            "match":{
    			"description":{
    				"query":"spring boot",
    				"operator":"or"
    			}
            }
        }
    }

query：搜索的关键字，对于英文关键字如果有多个单词则中间要用半角逗号分隔，而对于中文关键字中间可以用逗号分隔也可以不用。  
operator：or 表示 只要有一个词在文档中出现则就符合条件，and表示每个词都在文档中出现则才符合条件。

//根据关键字搜索
    @Test
    public void testMatchQuery() throws IOException {
        SearchRequest searchRequest = new SearchRequest("es_index");
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        //source源字段过虑
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel"}, new String[]{});
        //匹配关键字
        searchSourceBuilder.query(QueryBuilders.matchQuery("description", "spring boot").operator(Operator.OR));
        searchRequest.source(searchSourceBuilder);
        SearchResponse searchResponse = client.search(searchRequest);
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for (SearchHit hit : searchHits) {
            String index = hit.getIndex();
            String type = hit.getType();
            String id = hit.getId();
            float score = hit.getScore();
            String sourceAsString = hit.getSourceAsString();
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            String name = (String) sourceAsMap.get("name");
            String studymodel = (String) sourceAsMap.get("studymodel");
            String description = (String) sourceAsMap.get("description");
            System.out.println(name);
            System.out.println(studymodel);
            System.out.println(description);
        }
    }

2、minimum\_should\_match  
上边使用的operator = or表示只要有一个词匹配上就得分，如果实现三个词至少有两个词匹配如何实现？使用minimum\_should\_match可以指定文档匹配词的占比：

{
        "query":{
            "match":{
    			"description":{
    				"query":"spring boot 框架",
    				"minimum_should_match":"80%"
    			}
            }
        }
    }

设置"minimum\_should\_match": "80%"表示，三个词在文档的匹配占比为80%，即3\*0.8=2.4，向下取整得2，表示至少有两个词在文档中要匹配成功。

SearchRequest searchRequest = new SearchRequest("es_index");
         SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
    //匹配关键字
    MatchQueryBuilder matchQueryBuilder = QueryBuilders.matchQuery("description", "前台页面开发框架 架
    构")
    .minimumShouldMatch("80%");//设置匹配占比
    searchSourceBuilder.query(matchQueryBuilder);

7.2.6 multi Query

上边学习的termQuery和matchQuery一次只能匹配一个Field，本节学习multiQuery，一次可以匹配多个字段。  
1、基本使用  
单项匹配是在一个field中去匹配，多项匹配是拿关键字去多个Field中匹配。

{
        "query":{
            "multi_match":{
    			"query":"spring boot",
    			"minimum_should_match":"50%"，
    			"fields":["name","description"]
    			
            }
        }
    }

2、提升boost  
匹配多个字段时可以提升字段的 boost（权重）来提高得分

{
        "query":{
            "multi_match":{
    			"query":"spring boot",
    			"minimum_should_match":"50%"，
    			"fields":["name^10","description"]
    			
            }
        }
    }

“name^10” 表示权重提升10倍，执行上边的查询。

MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring 框架",
    "name", "description")
            .minimumShouldMatch("50%");
    multiMatchQueryBuilder.field("name",10);//提升boost

**7.2.7 布尔查询**

布尔查询对应于Lucene的BooleanQuery查询，实现将多个查询组合起来。

must：文档必须匹配must所包括的查询条件，相当于 “AND”  
    should：文档应该匹配should所包括的查询条件其中的一个或多个，相当于 “OR”  
    must\_not：文档不能匹配must\_not所包括的该查询条件，相当于“NOT”

{
        "_source":[
            "name",
            "studymodel",
            "description"
        ],
        "from":0,
        "size":1,
        "query":{
            "bool":{
                "must":[
                    {
                        "multi_match":{
                            "query":"spring框架",
                            "minimum_should_match":"50%",
                            "fields":[
                                "name^10",
                                "description"
                            ]
                        }
                    },
                    {
                        "term":{
                            "studymodel":"201001"
                        }
                    }
                ]
            }
        }
    }

//BoolQuery ，将搜索关键字分词，拿分词去索引库搜索
    @Test
    public void testBoolQuery() throws IOException {
        //创建搜索请求对象
        SearchRequest searchRequest= new SearchRequest("es_index");
        //创建搜索源配置对象
        SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        searchSourceBuilder.fetchSource(new String[]{"name","studymodel"},new String[]{});
        //multiQuery
        String keyword = "spring开发框架";
        MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery(
    "name", "description")
                .minimumShouldMatch("50%");
        multiMatchQueryBuilder.field("name",10);
        //TermQuery
        TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("studymodel", "201001");
        // 布尔查询
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
        boolQueryBuilder.must(multiMatchQueryBuilder);
        boolQueryBuilder.must(termQueryBuilder);
        //设置布尔查询对象
        searchSourceBuilder.query(boolQueryBuilder);
        searchRequest.source(searchSourceBuilder);//设置搜索源配置
        SearchResponse searchResponse = client.search(searchRequest);
        SearchHits hits = searchResponse.getHits();
        SearchHit[] searchHits = hits.getHits();
        for(SearchHit hit:searchHits){
            Map<String, Object> sourceAsMap = hit.getSourceAsMap();
            System.out.println(sourceAsMap);
        }
    }

**7.2.8 过滤器**

过虑是针对搜索的结果进行过虑，过虑器主要判断的是文档是否匹配，不去计算和判断文档的匹配度得分，所以过虑器性能比查询要高，且方便缓存，推荐尽量使用过虑器去实现查询或者过虑器和查询共同使用。过虑器在布尔查询中使用，下边是在搜索结果的基础上进行过虑：

{
        "_source":[
            "name",
            "studymodel",
            "description",
            "price"
        ],
        "query":{
            "bool":{
                "must":[
                    {
                        "multi_match":{
                            "query":"spring框架",
                            "minimum_should_match":"50%",
                            "fields":[
                                "name^10",
                                "description"
                            ]
                        }
                    }
                ],
                "filter":[
                    {
                        "term":{
                            "studymodel":"201001"
                        }
                    },
                    {
                        "range":{
                            "price":{
                                "gte":60,
                                "lte":100
                            }
                        }
                    }
                ]
            }
        }
    }

*  range：范围过虑，保留大于等于60 并且小于等于100的记录。
 *  term ：项匹配过虑，保留studymodel等于"201001"的记录。  
    注意：range和term一次只能对一个Field设置范围过虑。

// 布尔查询使用过虑器
      @Test
        public void testFilter() throws IOException {
            SearchRequest searchRequest = new SearchRequest("es_index");
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //source源字段过虑
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"},
    new String[]{});
            searchRequest.source(searchSourceBuilder);
            //匹配关键字
            MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("spring框
    架", "name", "description");
            //设置匹配占比
            multiMatchQueryBuilder.minimumShouldMatch("50%");
            //提升另个字段的Boost值
            multiMatchQueryBuilder.field("name",10);
            searchSourceBuilder.query(multiMatchQueryBuilder);
            //布尔查询
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            boolQueryBuilder.must(searchSourceBuilder.query());
            //过虑
            boolQueryBuilder.filter(QueryBuilders.termQuery("studymodel", "201001"));
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(60).lte(100));
            SearchResponse searchResponse = client.search(searchRequest);
            SearchHits hits = searchResponse.getHits();
            SearchHit[] searchHits = hits.getHits();
            for (SearchHit hit : searchHits) {
                String index = hit.getIndex();
                String type = hit.getType();
                String id = hit.getId();
                float score = hit.getScore();
                String sourceAsString = hit.getSourceAsString();
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                String studymodel = (String) sourceAsMap.get("studymodel");
                String description = (String) sourceAsMap.get("description");
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
          }

**7.2.9 排序**

可以在字段上添加一个或多个排序，支持在keyword、date、float等类型上添加，text类型的字段上不允许添加排序。

@Test 
        public void testSort() throws IOException {
             SearchRequest searchRequest = new SearchRequest("es_index");
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //source源字段过虑
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"}, new String[]{});
            searchRequest.source(searchSourceBuilder);
            //布尔查询
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            //过虑
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
            // 排序
            searchSourceBuilder.sort(new FieldSortBuilder("studymodel").order(SortOrder.DESC));
            searchSourceBuilder.sort(new FieldSortBuilder("price").order(SortOrder.ASC));
            SearchResponse searchResponse = client.search(searchRequest);
            SearchHits hits = searchResponse.getHits();
            SearchHit[] searchHits = hits.getHits();
            for (SearchHit hit : searchHits) {
                String index = hit.getIndex();
                String type = hit.getType();
                String id = hit.getId();
                float score = hit.getScore();
                String sourceAsString = hit.getSourceAsString();
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                String name = (String) sourceAsMap.get("name");
                String studymodel = (String) sourceAsMap.get("studymodel");
                String description = (String) sourceAsMap.get("description");
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
        }

**7.2.10 高亮显示**

高亮显示可以将搜索结果一个或多个字突出显示，以便向用户展示匹配关键字的位置。在搜索语句中添加highlight即可实现。

{
        "_source":[
            "name",
            "studymodel",
            "description",
            "price"
        ],
        "query":{
            "bool":{
                "filter":[
                    {
                        "range":{
                            "price":{
                                "gte":0,
                                "lte":100
                            }
                        }
                    }
                ]
            }
        },
        "sort":[
            {
                "studymodel":"desc"
            },
            {
                "price":"asc"
            }
        ],
        "highlight":{
            "pre_tags":[
                "<tag1>"
            ],
            "post_tags":[
                "</tag2>"
            ],
            "fields":{
                "name":{
    
                },
                "description":{
    
                }
            }
        }
    }

@Test
        public void testHighlight() throws IOException {
            SearchRequest searchRequest = new SearchRequest("es_index");
            SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
            //source源字段过虑
            searchSourceBuilder.fetchSource(new String[]{"name","studymodel","price","description"}, new String[]{});
            searchRequest.source(searchSourceBuilder);
            //匹配关键字
            MultiMatchQueryBuilder multiMatchQueryBuilder = QueryBuilders.multiMatchQuery("开发", "name", "description");
            searchSourceBuilder.query(multiMatchQueryBuilder);
            //布尔查询
            BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
            boolQueryBuilder.must(searchSourceBuilder.query());
            //过虑
            boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(0).lte(100));
            //排序
            searchSourceBuilder.sort(new FieldSortBuilder("studymodel").order(SortOrder.DESC));
            searchSourceBuilder.sort(new FieldSortBuilder("price").order(SortOrder.ASC));
            //高亮设置
            HighlightBuilder highlightBuilder = new HighlightBuilder();
            highlightBuilder.preTags("<tag>");//设置前缀
            highlightBuilder.postTags("</tag>");//设置后缀
            // 设置高亮字段
            highlightBuilder.fields().add(new HighlightBuilder.Field("name"));
            searchSourceBuilder.highlighter(highlightBuilder);
            SearchResponse searchResponse = client.search(searchRequest);
            SearchHits hits = searchResponse.getHits();
            SearchHit[] searchHits = hits.getHits();
            for (SearchHit hit : searchHits) {
                Map<String, Object> sourceAsMap = hit.getSourceAsMap();
                //名称
                String name = (String) sourceAsMap.get("name");
                //取出高亮字段内容
                Map<String, HighlightField> highlightFields = hit.getHighlightFields();
                if(highlightFields!=null){
                    HighlightField nameField = highlightFields.get("name");
                    if(nameField!=null){
                        Text[] fragments = nameField.getFragments();
                        StringBuffer stringBuffer = new StringBuffer();
                        for (Text str : fragments) {
                            stringBuffer.append(str.string());
                        }
                        name = stringBuffer.toString();
                    }
                }
                String index = hit.getIndex();
                String type = hit.getType();
                String id = hit.getId();
                float score = hit.getScore();
                String sourceAsString = hit.getSourceAsString();
                String studymodel = (String) sourceAsMap.get("studymodel");
                String description = (String) sourceAsMap.get("description");
                System.out.println(name);
                System.out.println(studymodel);
                System.out.println(description);
            }
        }

[https_github.com_o99o_SpringBoot_ElasticSearch.git]: https://github.com/o99o/SpringBoot_ElasticSearch.git
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70]: /images/20211126/7db75f586f1a444985f3aeb4b94925f8.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 1]: /images/20211126/13f62dfbdbf44f2b8f739e5594b28044.png
[https_www.elastic.co_guide_en_elasticsearch_reference_current_install-elasticsearch.html]: https://www.elastic.co/guide/en/elasticsearch/reference/current/install-elasticsearch.html
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 2]: /images/20211126/1633c355c8e44b278921da2bf2e3a03e.png
[http_localhost_9200]: http://localhost:9200
[https_blog.csdn.net_taotao_guiwang_article_details_98849857]: https://blog.csdn.net/taotao_guiwang/article/details/98849857
[http_localhost_9200 1]: http://localhost:9200/%E7%B4%A2%E5%BC%95%E5%BA%93%E5%90%8D%E7%A7%B0
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 3]: /images/20211126/f5e766329bc34f15a9c82fcaf5025a4a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 4]: /images/20211126/ca53ebe7848641eaa08bd15550360640.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 5]: /images/20211126/a62b67f3a36242e487337beb7c04ebab.png
[http_localhost_9200_es_index_doc_666]: http://localhost:9200/es_index/doc_type/6666
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 6]: /images/20211126/191d4859637e4209b38c45c1f53975ad.png
[http_localhost_9200_es_index_doc_search_q_name]: http://localhost:9200/es_index/doc_type/_search?q=name:%E5%85%A8%E6%96%87
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 7]: /images/20211126/03ef4d2a09914624960ea1d8adac8cc4.png
[http_localhost_9200_analyze]: http://localhost:9200/_analyze
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 8]: /images/20211126/4ebf77d7dd4748da978c74d69fda8e30.png
[https_github.com_medcl_elasticsearch-analysis-ik_releases]: https://github.com/medcl/elasticsearch-analysis-ik/releases
[Link 1]: https://github.com/medcl/elasticsearch-analysis-ik%EF%BC%89
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 9]: /images/20211126/9526168a7c754df0a4c42e1294c63a21.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 10]: /images/20211126/6bdeb8a9612b4740bfadd6dca4cb6f1e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 11]: /images/20211126/31aaf7b74b254ba59c3a38f43fcfe398.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 12]: /images/20211126/180c783b83504bdd82724a8a821ccb29.png
[http_localhost_9200_mapping]: http://localhost:9200/_mapping
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 13]: /images/20211126/1b3a86dfe52d42b5a4f1114e5599427d.png
[http_localhost_9200_es_index_mapping]: http://localhost:9200/es_index/doc_type/_mapping
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 14]: /images/20211126/fa6eaad377b14415a9063863c6c04cc1.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 15]: /images/20211126/2122bc0b480446b99cab86fb4fb09c5a.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 16]: /images/20211126/2b5910ff4a3841f1aa11c5dd21fd2f1e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 17]: /images/20211126/d2816c5a619945f7a7749698806f31fd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 18]: /images/20211126/82ad584505a141efb9724e30feb9470c.png
[http_localhost_9200_es_index]: http://localhost:9200/%E7%B4%A2%E5%BC%95%E5%90%8D%E7%A7%B0
[http_localhost_9200_es_index_mapping 1]: http://localhost:9200/es_learning/doc_type/_mapping
[http_localhost_9200_search]: http://localhost:9200/_search
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 19]: /images/20211126/6efb6c84f4b74584b8b359e717937f7e.png
[http_localhost_9200_es_index_doc_search]: http://localhost:9200/es_learning/doc_type/_search
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 20]: /images/20211126/52a2b770bac84847bf9ec30051e26e94.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 21]: /images/20211126/fdc7a55f79ff47a0aa5083476e38aba0.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3Rhb3Rhb19ndWl3YW5n_size_16_color_FFFFFF_t_70 22]: /images/20211126/d45c82a9f3d44c5e8da027effb156b96.png