Elasticsearch

简介

Elaticsearch，简称为es， es是一个开源的高扩展的分布式全文检索引擎，它可以近乎实时的检索数据；本身扩展性很好，可以扩展到上百台服务器，处理PB级别的数据。ES使用Java开发。Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。

核心概念

Elasticsearch是面向文档(document oriented)的，这意味着它可以存储整个对象或文档(document)。然而它不仅仅是存储，还会索引(index)每个文档的内容使之可以被搜索。在Elasticsearch中，你可以对文档（而非成行成列的数据）进行索引、搜索、排序、过滤。Elasticsearch比传统关系型数据库如下：

MYSQL(relational DB)	Databases(数据库)	Tables(表)	Rows(行)	Columns(列)	DDL(数据库定义语言)
Elasticsearch	Indexes(索引)	Types(类型)	Documents(文档)	Fields(字段)	mapping(映射)

索引

索引 index，在Elasticsearch中存储数据的行为就叫做索引(indexing)，一个索引由一个名字来标识（必须全部是小写字母的）。索引(index)这个词在Elasticsearch中有着不同的含义，所以有必要区分:

索引（名词）如上文所述，一个索引(index)就像是传统关系数据库中的数据库，它是相关文档存储的地方，index的复数是indices 或indexes。
索引（动词）「索引一个文档」表示把一个文档存储到索引（名词）里，以便它可以被检索或者查询。这很像SQL中的 INSERT 关键字。它与Insert差别是，如果文档已经存在，新的文档将覆盖旧的文档。

类型

类型 type，在一个索引中，可以定义一种或多种类型。相当于关系型数据库中的表。一个类型是你索引的一个逻辑上的分类或分区，其语义完全由你来定。通常，会为具有一组共同字段的文档定义一个类型。

比如说，我们假设你运营一个博客平台并且将你所有的数据存储到一个索引中。在这个索引中，你可以为用户数据定义一个类型(用户表)，为博客数据定义另一个类型(Article表)，当然，也可以为评论数据定义另一个类型(评论表)。

字段

字段Field，相当于数据表字段，对不同属性进行分类标识

映射

映射 mapping是处理数据的方式和规则，是针对字段做的一些限制，字段的配置。比如：某个字段的数据类型、默认值、分析器、是否被索引等等，这些都是映射里面设置的。其它就是处理es里面数据的一些使用规则设置也叫做映射，按着最优规则处理数据对性能提高很大，因此才需要建立映射，并且需要思考如何建立映射才能对性能更好。

文档

文档 document一个文档是一个可被索引的基础信息单元。比如，你可以拥有某一个客户的文档，某一个产品的一个文档，当然，也可以拥有某个订单的一个文档。文档以JSON（Javascript Object Notation）格式来表示，而JSON是一个到处存在的互联网数据交互格式。

在一个index/type里面，你可以存储任意多的文档。注意：文档必须被赋予一个索引的type。

Elasticsearch的操作

使用Postman工具进行RESTful接口访问

Elasticsearch的RESTful接口

请求方法：<verb> 
请求地址：<Protocol>://<Host>:<Port>/<Path>?<Query_String>
请求体：<Body>

其中：

参数	解释
`VERB`	适当的 HTTP 方法或谓词 : `GET`、 `POST`、 `PUT`、 `HEAD` 或者 `DELETE`。
`PROTOCOL`	`http` 或者 `https`（如果你在 Elasticsearch 前面有一个 `https` 代理）
`HOST`	Elasticsearch 集群中任意节点的主机名，或者用 `localhost` 代表本地机器上的节点。
`PORT`	运行 Elasticsearch HTTP 服务的端口号，默认是 `9200` 。
`PATH`	Path API 的终端路径（例如 `_count` 将返回集群中文档数量）。Path 可能包含多个组件，例如：`_cluster/stats` 和 `_nodes/stats/jvm` 。
`QUERY_STRING`	任意可选的查询字符串参数 (例如 `?pretty` 将格式化地输出 JSON 返回值，使其更容易阅读)
`BODY`	一个 JSON 格式的请求体 (如果请求需要的话)

创建索引

类比数据库的操作

发送方式

请求方式：PUT    
请求url：http://localhost:9200/blog2

返回成功结果

{
    "acknowledged": true,
    "shards_acknowledged": true,
    "index": "blog2"
}

创建索引时配置映射

请求方式：PUT    
请求url：http://localhost:9200/blog1

请求体：

{
    "mappings": {
        "article": {
            "properties": {
                "id": {
                    "type": "long",
                    "store": true,
                    "index":"not_analyzed"
                },
                "title": {
                    "type": "text",
                    "store": true,
                    "index":"analyzed",
                    "analyzer":"standard"
                },
                "content": {
                    "type": "text",
                    "store": true,
                    "index":"analyzed",
                    "analyzer":"standard"
                }
            }
        }
    }
}

类似于创建一个叫blog1的数据库
然后创建了一张叫article的表，里面有三列，分别为id,title,content

创建索引后配置映射

我们可以在创建索引时设置mapping信息，当然也可以先创建索引然后再设置mapping。

下面是直接使用put方法创建一个索引，然后设置mapping信息。

路径中有带“_”的表示的是Path API。

请求方法

请求方式：POST    
请求url：http://127.0.0.1:9200/blog1/addmapping/_mapping

请求体

{
    "addmapping": {
            "properties": {
                "id":{
                    "type":"long",
                    "store":true
                },
                "title":{
                    "type":"text",
                    "store":true,
                    "index":true,
                    "analyzer":"standard"
                },
                "content":{
                    "type":"text",
                    "store":true,
                    "index":true,
                    "analyzer":"standard"
                }
            }
        }
  }

删除索引

请求方式：DELETE        
请求url：http://localhost:9200/blog1

创建文档

地址最后的值为索引库中文档的ID，如果不传会随机生成一个。

请求方式：POST    
请求url：http://localhost:9200/blog1/article/1

请求体

{
    "id":1,
    "title":"Elasticsearch是一个基于Lucene的搜索服务器",
    "content":"它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。"
}

成功后返回信息

{
    "_index": "blog1",
    "_type": "article",
    "_id": "1",
    "_version": 1,
    "result": "created",
    "_shards": {
        "total": 2,
        "successful": 1,
        "failed": 0
    },
    "created": true
}

其中_id是地址栏中的那个id，也就是上面请求url中结尾的1

请求体中的id是本身文档的内容

修改文档

请求方式：POST    
请求url：http://localhost:9200/blog1/article/1

请求体

{
    "id":1,
    "title":"【修改】Elasticsearch是一个基于Lucene的搜索服务器",
    "content":"【修改】它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。"
}

删除文档

请求方式：DELETE    
请求url：http://localhost:9200/blog1/article/1

根据id查询

请求方式：GET    
请求url：http://localhost:9200/blog1/article/1

成功后返回

{
    "_index": "blog1",
    "_type": "article",
    "_id": "1",
    "_version": 1,
    "found": true,
    "_source": {
        "id": 1,
        "title": "Elasticsearch是一个基于Lucene的搜索服务器",
        "content": "它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。"
    }
}

querystring查询(重要)

query_string是带分词器的查询

分词器即将储存时的数据和搜索的语句划分为关键词
比如我往索引中存储了一条我是茶叶蛋的数据
那么在存储数据时，分词器（标准模式）就会将这条数据划分为我，是，茶，叶，蛋五个关键词
那么在搜索中，只要我数据中的关键词与你搜索的语句中经过分词器后的关键词只要有一个匹配，就命中

请求方式：POST
请求url：http://localhost:9200/blog1/article/_search

这里注意是Post方式，因为需要带请求体

请求体

{
    "query": {
        "query_string": {
            "default_field": "title",
            "query": "搜索服务器"
        }
    }
}

default_field搜索域，即这里在title中进行搜索
query搜索语句

term查询

term查询，关键词匹配

请求url

请求方式：POST
请求url：http://localhost:9200/blog1/article/_search

请求体

{
    "query": {
        "term": {
            "title": "搜索"
        }
    }
}

返回结果

{
    "took": 1,
    "timed_out": false,
    "_shards": {
        "total": 5,
        "successful": 5,
        "skipped": 0,
        "failed": 0
    },
    "hits": {
        "total": 0,
        "max_score": null,
        "hits": []
    }
}

IK 分词器和Elasticsearch集成使用

简介

IKAnalyzer是一个开源的，基于java语言开发的轻量级的中文分词工具包。从2006年12月推出1.0版开始，IKAnalyzer已经推出了3个大版本。最初，它是以开源项目Lucene为应用主体的，结合词典分词和文法分析算法的中文分词组件。新版本的IKAnalyzer3.0则发展为面向Java的公用分词组件，独立于Lucene项目，同时提供了对Lucene的默认优化实现。

IK分词器3.0的特性如下：

1）采用了特有的“正向迭代最细粒度切分算法“，具有60万字/秒的高速处理能力。
2）采用了多子处理器分析模式，支持：英文字母（IP地址、Email、URL）、数字（日期，常用中文数量词，罗马数字，科学计数法），中文词汇（姓名、地名处理）等分词处理。
3）对中英联合支持不是很好，在这方面的处理比较麻烦.需再做一次查询，同时是支持个人词条的优化的词典存储，更小的内存占用。
4）支持用户词典扩展定义。
5）针对Lucene全文检索优化的查询分析器IKQueryParser；采用歧义分析算法优化查询关键字的搜索排列组合，能极大的提高Lucene检索的命中率。

Elasticsearch集成IK分词器

下载地址：https://github.com/medcl/Elasticsearch-analysis-ik/releases

注意要与Elasticsearch版本对应

将解压后的Elasticsearch文件夹拷贝到Elasticsearch-5.6.8\plugins下，并重命名文件夹为analysis-ik。重新启动Elasticsearch，即可加载IK分词器

分词算法

IK提供了两个分词算法ik_smart 和 ik_max_word

其中 ik_smart 为最少切分，ik_max_word为最细粒度划分

修改索引映射mapping

重建索引

建立mapping后，"analyzer"是不能够更改的，所以必须重建索引。

说不能更改其实不准确，更重要的原因是，在存储数据时分词器已经把关键词都分好了

删除原有blog1索引

请求方式：DELETE
请求地址：http://localhost:9200/blog1

创建blog1索引，此时分词器使用ik_max_word

请求方式：PUT
请求地址：http://localhost:9200/blog1

{
    "mappings": {
        "article": {
            "properties": {
                "id": {
                    "type": "long",
                    "store": true,
                    "index":"not_analyzed"
                },
                "title": {
                    "type": "text",
                    "store": true,
                    "index":"analyzed",
                    "analyzer":"ik_max_word"
                },
                "content": {
                    "type": "text",
                    "store": true,
                    "index":"analyzed",
                    "analyzer":"ik_max_word"
                }
            }
        }
    }
}

创建文档

请求方式：POST
请求地址：http://localhost:9200/blog1/article/1

{
    "id":1,
    "title":"Elasticsearch是一个基于Lucene的搜索服务器",
    "content":"它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。"
}

再次测试queryString查询

请求url：

请求方式：POST    
请求地址：http://localhost:9200/blog1/article/_search

请求体：

{
    "query": {
        "query_string": {
            "default_field": "title",
            "query": "搜索服务器"
        }
    }
}

就可以成功且准确的搜索结果了。

Elasticsearch集群

Elasticsearch集群是一个 P2P类型(使用 gossip 协议)的分布式系统，除了集群状态管理以外，其他所有的请求都可以发送到集群内任意一台节点上，这个节点可以自己找到需要转发给哪些节点，并且直接跟这些节点通信。所以，从网络架构及服务配置上来说，构建集群所需要的配置极其简单。在 Elasticsearch 2.0 之前，无阻碍的网络下，所有配置了相同 cluster.name 的节点都自动归属到一个集群中。2.0 版本之后，基于安全的考虑避免开发环境过于随便造成的麻烦，从 2.0 版本开始，默认的自动发现方式改为了单播(unicast)方式。配置里提供几台节点的地址，ES 将其视作 gossip router 角色，借以完成集群的发现。由于这只是 ES 内一个很小的功能，所以 gossip router 角色并不需要单独配置，每个 ES 节点都可以担任。所以，采用单播方式的集群，各节点都配置相同的几个节点列表作为 router 即可。

集群中节点数量没有限制，大于等于2个节点就可以看做是集群了。一般出于高性能及高可用方面来考虑集群中节点数量都是3个以上。

集群的相关概念

集群 cluster

一个集群就是由一个或多个节点组织在一起，它们共同持有整个的数据，并一起提供索引和搜索功能。一个集群由一个唯一的名字标识，这个名字默认就是“Elasticsearch”。这个名字是重要的，因为一个节点只能通过指定某个集群的名字，来加入这个集群

节点 node

一个节点是集群中的一个服务，作为集群的一部分，它存储数据，参与集群的索引和搜索功能。和集群类似，一个节点也是由一个名字来标识的。这个名字对于管理工作来说挺重要的，因为在这个管理过程中，你会去确定网络中的哪些服务对应于Elasticsearch集群中的哪些节点。

一个节点可以通过配置集群名称的方式来加入一个指定的集群。默认情况下，每个节点都会被安排加入到一个叫做“Elasticsearch”的集群中，这意味着，如果你在你的网络中启动了若干个节点，并假定它们能够相互发现彼此，它们将会自动地形成并加入到一个叫做“Elasticsearch”的集群中。在一个集群里，只要你想，可以拥有任意多个节点。

分片和复制 shards&replicas

为了解决索引占用空间过大(1TB以上)这个问题，Elasticsearch提供了将索引划分成多份的能力，这些份就叫做分片。当你创建一个索引的时候，你可以指定你想要的分片的数量。

为了提高分片高可用，Elasticsearch允许创建分片的一份或多份拷贝，这些拷贝叫做复制分片，或者直接叫复制。

默认情况下，Elasticsearch中的每个索引被分片5个主分片和1个复制，这意味着，如果你的集群中至少有两个节点，你的索引将会有5个主分片和另外5个复制分片（1个完全拷贝），这样的话每个索引总共就有10个分片。

集群的搭建

因为经费有限，在本机上开三个节点当集群

修改每台服务器配置

修改Elasticsearch-cluster\node*\config\Elasticsearch.yml配置文件

node1节点

#节点1的配置信息：
#集群名称，保证唯一
cluster.name: my-Elasticsearch
#节点名称，必须不一样
node.name: node-1
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9201
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9301
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

node2节点

#节点2的配置信息：
#集群名称，保证唯一
cluster.name: my-Elasticsearch
#节点名称，必须不一样
node.name: node-2
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9202
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9302
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

node3节点

#节点3的配置信息：
#集群名称，保证唯一
cluster.name: my-Elasticsearch
#节点名称，必须不一样
node.name: node-3
#必须为本机的ip地址
network.host: 127.0.0.1
#服务端口号，在同一机器下必须不一样
http.port: 9203
#集群间通信端口号，在同一机器下必须不一样
transport.tcp.port: 9303
#设置集群自动发现机器ip集合
discovery.zen.ping.unicast.hosts: ["127.0.0.1:9301","127.0.0.1:9302","127.0.0.1:9303"]

启动各个节点服务器

双击Elasticsearch-cluster\node*\bin\Elasticsearch.bat

进入游览器可视化界面

ElasticSearch Java客户端

客户端开发环境搭建

创建Maven工程

导入坐标

<dependencies>
    <dependency>
        <groupId>org.elasticsearch</groupId>
        <artifactId>elasticsearch</artifactId>
        <version>5.6.8</version>
    </dependency>
    <dependency>
        <groupId>org.elasticsearch.client</groupId>
        <artifactId>transport</artifactId>
        <version>5.6.8</version>
    </dependency>
</dependencies>

创建索引index

Java客户端的操作，模仿我们通过postman发送请求调用RESTful接口调用的方式，本质还是请求获取响应。只不过使用的不是http协议而是tcp。使用ES的编程工具包，编写Java代码，代码运行结果会在ES服务中创建索引

/**
 * 目标：创建索引操作
 * Java代码创建索引：一切对象
 * 1、客户端对象：请求url地址，请求端口9300
 * 2、请求对象：不同操作对应不同的请求对象
 * 3、发送请求方法get()
 * 4、返回响应对象
 * 5、释放资源，关闭客户端对象
 */
public class Demo01CreateIndex {
    public static void main(String[] args) throws UnknownHostException {
        // 1、客户端对象：elasticsearch 服务url地址，请求端口9300
        Settings settings = Settings.builder().build();
        PreBuiltTransportClient client = new PreBuiltTransportClient(settings);
        InetSocketTransportAddress address = new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300);
        client.addTransportAddress(address);
        // 2、请求对象：不同操作对应不同的请求对象
        AdminClient adminClient = client.admin();//管理权限客户端
        IndicesAdminClient indicesAdminClient = adminClient.indices();//创建索引管理权限客户端
        CreateIndexRequestBuilder request = indicesAdminClient.prepareCreate("blog1");
        // 3、发送请求方法get()、返回响应对象
        CreateIndexResponse response = request.get();
        System.out.println("index::::"+response.index());
        // 4、释放资源，关闭客户端对象
        client.close();

    }
}

配置索引映射mapping

创建索引和配置映射本质都是一次请求，相比于索引创建映射的创建需要请求体内容。

/**
 * 目标:创建索引的type的映射
 * 1.获取客户端
 * 2.创建mapping请求对象:需要设置index,type,请求体
 * 3.创建JSON请求体:参考第一天的设置Mapping的JSON数据
 * 4.请求对象执行发送请求操作,请求完成会获取响应对象
 * 5.关闭客户端
 */
@Test
public void createMapping() throws IOException, ExecutionException, InterruptedException {
        //配置集群名称，注意采用的事情TCP接口调用
        Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
        //配置请求地址和端口
        InetSocketTransportAddress address = new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300);
        PreBuiltTransportClient client = new PreBuiltTransportClient(settings);
        client.addTransportAddress(address);
        //* 1.获取客户端
        //* 2.创建mapping请求对象:需要设置index,type,请求体
        PutMappingRequestBuilder request = client.admin().indices().preparePutMapping("blog3");
        request.setType("article");//设置type
        //* 3.创建JSON请求体:参考第一天的设置Mapping的JSON数据
        XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
        jsonBuilder.startObject()
                .startObject("article")
                .startObject("properties")
                .startObject("id").field("type","long").field("store","yes").field("index","not_analyzed")
                .endObject()
                .startObject("title").field("type","string").field("store","yes").field("index","analyzed").field("analyzer","ik_smart")
                .endObject()
                .startObject("content").field("type","string").field("store","yes").field("index","analyzed").field("analyzer","ik_smart")
                .endObject()
                .endObject()
                .endObject()
                .endObject();
        request.setSource(jsonBuilder);//设置请求体
        //* 4.请求对象执行发送请求操作,请求完成会获取响应对象
        PutMappingResponse response = request.get();
        System.out.println(response.toString());
        //* 5.关闭客户端
        client.close();
}

建立文档document

通过XContentBuilder

/**
 * 目标:创建文档
 * 1.获取客户端
 * 2.创建索引设置文档请求对象:需要设置index,type,id,请求体
 * 3.创建JSON请求体:参考第一天的设置创建文档的JSON数据
 * 4.请求对象执行发送请求操作,请求完成会获取响应对象
 * 5.关闭客户端
 */
@Test
public void createDocument() throws IOException {
    //* 1.获取客户端：设置集群名称，设置请求地址和端口TCP的
    Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
    InetSocketTransportAddress address = new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300);
    PreBuiltTransportClient client = new PreBuiltTransportClient(settings);
    client.addTransportAddress(address);
    //* 3.创建JSON请求体:参考第一天的设置创建文档的JSON数据
    XContentBuilder jsonBuilder = XContentFactory.jsonBuilder();
    jsonBuilder.startObject()
            .field("id","1")
            .field("title","ELasticSearch是一个基于Lucene的搜索服务器")
            .field("content","content它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。")
            .endObject();
    //* 2.创建索引设置文档请求对象:需要设置index,type,id,请求体
    IndexRequestBuilder requestBuilder = client.prepareIndex("blog3", "article", "1");
    requestBuilder.setSource(jsonBuilder);
    //* 4.请求对象执行发送请求操作,请求完成会获取响应对象
    IndexResponse indexResponse = requestBuilder.get();
    System.out.println(indexResponse.toString());
    //* 5.关闭客户端
    client.close();
}

使用Jackson转换实体

1）创建Article实体

public class Article {
    private Integer id;
    private String title;
    private String content;
    getter/setter...
}

2）添加jackson坐标

<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-core</artifactId>
    <version>2.8.1</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-databind</artifactId>
    <version>2.8.1</version>
</dependency>
<dependency>
    <groupId>com.fasterxml.jackson.core</groupId>
    <artifactId>jackson-annotations</artifactId>
    <version>2.8.1</version>
</dependency>

3）代码实现

/**
 * 目标:创建文档(第二种方式对象转换且JSON字符串)
 * 1.获取客户端
 * 2.创建索引设置文档请求对象:需要设置index,type,id,请求体
 * 3.创建文章对象,对象转换JSON的字符串;请求对象设置字符串
 * 4.请求对象执行发送请求操作,请求完成会获取响应对象
 * 5.关闭客户端
 *
 * 其实还有:第三种方式JSONString,第四种方式map
 */
@Test
public void createDocumentTwo() throws UnknownHostException, JsonProcessingException {
    //* 1.获取客户端
    PreBuiltTransportClient client = TransPortClientUtil.getClient();
    //* 2.创建索引设置文档请求对象:需要设置index,type,id,请求体
    IndexRequestBuilder indexRequestBuilder = client.prepareIndex("blog3", "article", "1");
    //* 3.创建文章对象,对象转换JSON的字符串;请求对象设置字符串
    Article article = new Article();
    article.setId(1);
    article.setTitle("ELasticSearch是一个基于Lucene的搜索服务器");
    article.setContent("content它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开放源码发布，是当前流行的企业级搜索引擎。设计用于云计算中，能够达到实时搜索，稳定，可靠，快速，安装使用方便。");
    ObjectMapper objectMapper = new ObjectMapper();
    String jsonArticle = objectMapper.writeValueAsString(article);
    indexRequestBuilder.setSource(jsonArticle);
    //* 4.请求对象执行发送请求操作,请求完成会获取响应对象
    IndexResponse indexResponse = indexRequestBuilder.get();
    //* 5.关闭客户端
    client.close();
}

查询文档操作

关键词查询

/**
 * 目标:term关键词的查询
 * 1.获取客户端
 * 2.创建搜索请求对象:需要设置index,type,查询对象
 * 3.创建Term查询对象,设置查询字段,和关键词
 * 4.请求对象执行发送请求操作,请求完成会获取响应对象
 * 5.响应对象中获取命中数据,循环遍历输出
 * 6.关闭客户端
 */
@Test
public void testTermQuery() throws UnknownHostException {
    //* 1.获取客户端
    PreBuiltTransportClient client = TransPortClientUtil.getClient();
    //* 2.创建搜索请求对象:需要设置index,type,查询对象
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog3");
    //* 3.创建Term查询对象,设置查询字段,和关键词
    searchRequestBuilder.setQuery(QueryBuilders.termQuery("title","搜索"));
    //* 4.请求对象执行发送请求操作,请求完成会获取响应对象
    SearchResponse searchResponse = searchRequestBuilder.get();
    //* 5.响应对象中获取命中数据,循环遍历输出
    SearchHits hits = searchResponse.getHits();
    for (SearchHit hit : hits) {
        System.out.println(hit.getSourceAsString());
        System.out.println(hit.getSource().get("id"));
        System.out.println(hit.getSource().get("title"));
        System.out.println(hit.getSource().get("content"));
    }
    //* 6.关闭客户端
    client.close();
}

字符串查询

/**
 * 目标:查询,带分词器的字符串查询
 * 1.获取客户端
 * 2.创建搜索请求对象:需要设置index,type,查询对象
 * 3.创建Query_string查询对象,传入查询字符串
 * 4.请求对象执行发送请求操作,请求完成会获取响应对象
 * 5.响应对象中获取命中数据,循环遍历输出
 * 6.关闭客户端
 */
@Test
public void testStringQuery() throws UnknownHostException {
    //1.获取客户端
    PreBuiltTransportClient client = TransPortClientUtil.getClient();
    //2.创建搜索请求对象:需要设置index,type,查询对象
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog2");
    searchRequestBuilder.setTypes("article");
    //3.创建Query_string查询对象,传入查询字符串
    searchRequestBuilder.setQuery(QueryBuilders.queryStringQuery("搜索"));
    //4.请求对象执行发送请求操作,请求完成会获取响应对象
    SearchResponse searchResponse = searchRequestBuilder.get();//发送请求获取响应
    //5.响应对象中获取命中数据,循环遍历输出
    SearchHits hits = searchResponse.getHits();
    System.out.println("搜索结果有:[" + hits.getTotalHits() + "]条");
    Iterator<SearchHit> iterator = hits.iterator();
    while (iterator.hasNext()){
        SearchHit next = iterator.next();
        System.out.println("ID:"+next.getSource().get("id"));
        System.out.println("title:"+next.getSource().get("title"));
        System.out.println("content:"+next.getSource().get("content"));
    }
    //6.关闭客户端
    client.close();
}

使用文档ID查询文档

/**
 * 目标:查询,使用ID查询
 * 1.获取客户端
 * 2.创建搜索请求对象:需要设置index,type,查询对象
 * 3.创建idsQuery查询对象,填入id
 * 4.请求对象执行发送请求操作,请求完成会获取响应对象
 * 5.响应对象中获取命中数据,循环遍历输出
 * 6.关闭客户端
 */
@Test
public void findById() throws UnknownHostException {
    //1.获取客户端
    PreBuiltTransportClient client = TransPortClientUtil.getClient();
    //2.创建搜索请求对象:需要设置index,type,查询对象
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog1");
    searchRequestBuilder.setTypes("article");
    //3.创建idsQuery查询对象,填入id
    searchRequestBuilder.setQuery(QueryBuilders.idsQuery().addIds("1"));
    //4.请求对象执行发送请求操作,请求完成会获取响应对象
    SearchResponse searchResponse = searchRequestBuilder.get();
    //5.响应对象中获取命中数据,循环遍历输出
    SearchHits hits = searchResponse.getHits();
    System.out.println("搜索结果有:[" + hits.getTotalHits() + "]条");
    Iterator<SearchHit> iterator = hits.iterator();
    while (iterator.hasNext()){
        SearchHit next = iterator.next();
        System.out.println("ID:"+next.getSource().get("id"));
        System.out.println("title:"+next.getSource().get("title"));
        System.out.println("content:"+next.getSource().get("content"));
    }
    //6.关闭客户端
    client.close();
}

分页查询

/**
 * 目标:查询,分页查询
 * 1.获取客户端
 * 2.创建搜索请求对象:需要设置index,type,查询对象
 * 3.创建查询所有记录对象,并设置分页信息:form表示起始页,size表示每页多少条
 * 4.请求对象执行发送请求操作,请求完成会获取响应对象
 * 5.响应对象中获取命中数据,循环遍历输出
 * 6.关闭客户端
 */
@Test
public void findByPageable() throws UnknownHostException {
    //1.获取客户端
    PreBuiltTransportClient client = TransPortClientUtil.getClient();
    //2.创建搜索请求对象:需要设置index,type,查询对象
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog2");
    searchRequestBuilder.setTypes("article");
    //3.创建查询所有记录对象,并设置分页信息:form表示起始页,size表示每页多少条
    searchRequestBuilder.setQuery(QueryBuilders.matchAllQuery());//默认每页10条
    searchRequestBuilder.setFrom(0);//form表示起始页
    searchRequestBuilder.setSize(20);//size表示每页多少条
    //4.请求对象执行发送请求操作,请求完成会获取响应对象
    SearchResponse searchResponse = searchRequestBuilder.get();
    //5.响应对象中获取命中数据,循环遍历输出
    SearchHits hits = searchResponse.getHits();
    System.out.println("搜索结果有:[" + hits.getTotalHits() + "]条");
    System.out.println("当前页有:[" + hits.getHits().length + "]条");
    Iterator<SearchHit> iterator = hits.iterator();
    while (iterator.hasNext()){
        SearchHit next = iterator.next();
        System.out.println("ID:"+next.getSource().get("id"));
        System.out.println("title:"+next.getSource().get("title"));
        System.out.println("content:"+next.getSource().get("content"));
    }
    //6.关闭客户端
    client.close();
}

其中，自带默认是每页十条

查询结果高亮操作

ElasticSearch可以对查询出的内容中关键字部分进行标签和样式的设置，但是你需要告诉ElasticSearch使用什么标签对高亮关键字进行包裹

/**
 * 目标:搜索结果高亮
 * 1.获取客户端
 * 2.创建搜索请求对象:需要设置index,type,查询对象
 * 3.创建Term查询对象,设置查询字段,和关键词
 *  3.1 查询对象设置数据高亮配置:配置高亮标签font,配置高亮字段title
 * 4.请求对象执行发送请求操作,请求完成会获取响应对象
 * 5.响应对象中获取命中数据,循环遍历输出
 * 6.关闭客户端
 */
@Test
public void testHighLight() throws UnknownHostException {
    //1.获取客户端
    PreBuiltTransportClient client = TransPortClientUtil.getClient();
    //2.创建搜索请求对象:需要设置index,type,查询对象
    SearchRequestBuilder searchRequestBuilder = client.prepareSearch("blog2");
    searchRequestBuilder.setTypes("article");
    //3.创建Term查询对象,设置查询字段,和关键词
    searchRequestBuilder.setQuery(QueryBuilders.termQuery("title","搜索"));//默认每页10条

    //3.1 查询对象设置数据高亮配置
    HighlightBuilder highlightBuilder = new HighlightBuilder();
    highlightBuilder.preTags("<font style='color:red'>");
    highlightBuilder.postTags("</font>");
    highlightBuilder.field("title");

    searchRequestBuilder.highlighter(highlightBuilder);

    //4.请求对象执行发送请求操作,请求完成会获取响应对象
    SearchResponse searchResponse = searchRequestBuilder.get();
    //5.响应对象中获取命中数据,循环遍历输出
    SearchHits hits = searchResponse.getHits();
    System.out.println("共搜索到:[" + hits.getTotalHits() + "]条结果");
    for (SearchHit hit : hits) {
        System.out.println("String方式打印高亮内容:");
        System.out.println(hit.getSourceAsString());
        System.out.println("Map方式打印高亮内容:");
        System.out.println(hit.getHighlightFields());
        Map<String, HighlightField> highlightFieldMap = hit.getHighlightFields();

        Text[] titles = hit.getHighlightFields().get("title").fragments();
        for (Text title : titles) {
            System.out.println(title);
        }
    }
    //6.关闭客户端
    client.close();
}

Spring Data ElasticSearch

Spring Data是一个用于==简化数据访问==，并支持云服务的开源框架。其主要目标是使得对数据的访问变得方便快捷。 Spring Data可以极大的简化数据操作的写法，可以在几乎不用写实现的情况下，实现对数据的访问和操作。除了CRUD外，还包括如分页、排序等一些常用的功能。

Spring Data的官网：http://projects.spring.io/spring-data/

Spring Data ElasticSearch 基于 spring data API 简化 elasticSearch操作，将原始操作elasticSearch的客户端API 进行封装。Spring Data为Elasticsearch项目提供集成搜索引擎。Spring Data Elasticsearch POJO的关键功能区域为中心的模型与Elastichsearch交互文档和轻松地编写一个存储库数据访问层。

官方网站：http://projects.spring.io/spring-data-elasticsearch/

环境搭建

导入Spring Data ElasticSearch坐标

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.chayedan</groupId>
    <artifactId>chayedan_elasticsearch_demo3</artifactId>
    <version>1.0-SNAPSHOT</version>


    <dependencies>
        <dependency>
            <groupId>org.elasticsearch</groupId>
            <artifactId>elasticsearch</artifactId>
            <version>5.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.elasticsearch.client</groupId>
            <artifactId>transport</artifactId>
            <version>5.6.8</version>
        </dependency>
        <dependency>
            <groupId>org.apache.logging.log4j</groupId>
            <artifactId>log4j-to-slf4j</artifactId>
            <version>2.9.1</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-api</artifactId>
            <version>1.7.24</version>
        </dependency>
        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-simple</artifactId>
            <version>1.7.21</version>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.12</version>
        </dependency>
        <dependency>
            <groupId>junit</groupId>
            <artifactId>junit</artifactId>
            <version>4.12</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-core</artifactId>
            <version>2.8.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-databind</artifactId>
            <version>2.8.1</version>
        </dependency>
        <dependency>
            <groupId>com.fasterxml.jackson.core</groupId>
            <artifactId>jackson-annotations</artifactId>
            <version>2.8.1</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.data</groupId>
            <artifactId>spring-data-elasticsearch</artifactId>
            <version>3.0.5.RELEASE</version>
            <exclusions>
                <exclusion>
                    <groupId>org.elasticsearch.plugin</groupId>
                    <artifactId>transport-netty4-client</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
        <dependency>
            <groupId>org.springframework</groupId>
            <artifactId>spring-test</artifactId>
            <version>5.0.4.RELEASE</version>
        </dependency>
    </dependencies>
</project>

创建applicationContext.xml配置文件，引入elasticsearch命名空间

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
    xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    xmlns:context="http://www.springframework.org/schema/context"
    xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
    xsi:schemaLocation="
        http://www.springframework.org/schema/beans 
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context 
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/data/elasticsearch
        http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd">
</beans>

编写实体Article

package com.chayedan.domain;

public class Article {

    private Integer id;
    private String title;
    private String content;
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    @Override
    public String toString() {
        return "Article [id=" + id + ", title=" + title + ", content=" + content + "]";
    }
}

编写Dao

package com.chayedan.dao;

import com.chayedan.domain.Article;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;

@Repository
public interface ArticleRepository extends ElasticsearchRepository<Article, Integer> {

}

ElasticsearchRepository<Article, Integer> 接口的第一个参数是当前实体类，第二个参数是实体类主键的类型

编写Service

package com.chayedan.service;

import com.chayedan.domain.Article;

public interface ArticleService {

    public void save(Article article);
    
}

package com.chayedan.service.impl;

import com.chayedan.dao.ArticleRepository;
import com.chayedan.domain.Article;
import com.chayedan.service.ArticleService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ArticleServiceImpl implements ArticleService {

    @Autowired
    private ArticleRepository articleRepository;

    public void save(Article article) {
        articleRepository.save(article);
    }

}

其实持久层（Dao层）继承的ElasticsearchRepository接口已经帮我们实现了常用的方法。可以通过Dao直接调用，但最好不要这样，因为违反了规范。还是创建一个service接口来调用，创建也很简单，alt加回车。懂吧。

配置applicationContext.xml

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:elasticsearch="http://www.springframework.org/schema/data/elasticsearch"
       xsi:schemaLocation="
        http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        http://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/data/elasticsearch
        http://www.springframework.org/schema/data/elasticsearch/spring-elasticsearch-1.0.xsd
        ">
    
    <!-- 扫描Dao包，自动创建实例 -->
    <elasticsearch:repositories base-package="com.chayedan.dao"/>

    <!-- 扫描Service包，创建Service的实体 -->
    <context:component-scan base-package="com.chayedan.service"/>

    <!-- 配置elasticSearch的连接 -->
        <!-- 配置elasticSearch的连接 -->
    <elasticsearch:transport-client id="client" cluster-nodes="localhost:9300" cluster-name="elasticsearch"/>


    <!-- ElasticSearch模版对象 -->
    <bean id="elasticsearchTemplate" class="org.springframework.data.elasticsearch.core.ElasticsearchTemplate">
        <constructor-arg name="client" ref="client"></constructor-arg>
    </bean>
    
</beans>

配置实体

基于spring data elasticsearch注解配置索引、映射和实体的关系

package com.chayedan.domain;

import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;

//@Document 文档对象 （索引信息、文档类型 ）
@Document(indexName="blog3",type="article")
public class Article {

    //@Id 文档主键 唯一标识
    @Id
    //@Field 每个文档的字段配置（类型、是否分词、是否存储、分词器 ）
    @Field(store=true, index = false,type = FieldType.Integer)
    private Integer id;
    @Field(index=true,analyzer="ik_smart",store=true,searchAnalyzer="ik_smart",type = FieldType.text)
    private String title;
    @Field(index=true,analyzer="ik_smart",store=true,searchAnalyzer="ik_smart",type = FieldType.text)
    private String content;
    
    public Integer getId() {
        return id;
    }
    public void setId(Integer id) {
        this.id = id;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getContent() {
        return content;
    }
    public void setContent(String content) {
        this.content = content;
    }
    @Override
    public String toString() {
        return "Article [id=" + id + ", title=" + title + ", content=" + content + "]";
    }
}

其中，注解解释如下：
@Document(indexName="blob3",type="article")：
indexName：索引的名称（必填项）
type：索引的类型
@Id：主键的唯一标识
@Field(index=true,analyzer="ik_smart",store=true,searchAnalyzer="ik_smart",type = FieldType.text)
index：是否设置分词
analyzer：存储时使用的分词器
searchAnalyze：搜索时使用的分词器
store：是否存储
type: 数据类型

创建测试类SpringDataESTest

package com.chayedan.test;

import com.chayedan.domain.Article;
import com.chayedan.service.ArticleService;
import org.elasticsearch.client.transport.TransportClient;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations="classpath:applicationContext.xml") //别忘了这个注解
public class SpringDataESTest {

    @Autowired
    private ArticleService articleService;

    @Autowired
    private TransportClient client;

    @Autowired
    private ElasticsearchTemplate elasticsearchTemplate;

    /**创建索引和映射*/
    @Test
    public void createIndex(){
        elasticsearchTemplate.createIndex(Article.class);
        elasticsearchTemplate.putMapping(Article.class);
    }

    /**测试保存文档*/
    @Test
    public void saveArticle(){
        Article article = new Article();
        article.setId(100);
        article.setTitle("测试SpringData ElasticSearch");
        article.setContent("Spring Data ElasticSearch 基于 spring data API 简化 elasticSearch操作，将原始操作elasticSearch的客户端API 进行封装Spring Data为Elasticsearch Elasticsearch项目提供集成搜索引擎");
        articleService.save(article);
    }
}

常用操作

测试类

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:applicationContext.xml")
public class SpringDataES {

    @Autowired
    ArticleService articleService;

    @Autowired
    ElasticsearchTemplate elasticsearchTemplate;//es模板对象

    //创建索引，配置映射
    @Test
    public void createIndex(){
        elasticsearchTemplate.createIndex(Article.class);//创建索引
        elasticsearchTemplate.putMapping(Article.class);//配置映射
    }
    //创建文档
    @Test
    public void createDoc(){
        Article article = new Article();
        article.setId(1);
        article.setTitle("ElasticSearch是一个基于Lucene的搜索服务器");
        article.setContent("它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开.");
        articleService.save(article);
    }
    //修改文档
    @Test
    public void update(){
        Article article = new Article();
        article.setId(1);
        article.setTitle("【修改】ElasticSearch是一个基于Lucene的搜索服务器");
        article.setContent("【修改】它提供了一个分布式多用户能力的全文搜索引擎，基于RESTful web接口。Elasticsearch是用Java开发的，并作为Apache许可条款下的开.");
        articleService.update(article);
    }
    //删除文档
    @Test
    public void del(){
        Article article = new Article();
        article.setId(1);
        articleService.delete(article);
    }
    //基本查询
    //findById
    @Test
    public void findById(){
        Article article =  articleService.findById(1);
        System.out.println(article);
    }
    //findAll
    @Test
    public void findAll(){
        Iterable<Article> articles =  articleService.findAll();
        int count=0;
        for (Article article : articles) {
            System.out.println(article);
            count++;
        }
        System.out.println("总条数:" + count);
    }
    // 分页查询
    @Test
    public void findByPage(){

        int currentPage=0;
        int size = 2;
        Page<Article> articles =  articleService.findAll(currentPage,size);
        for (Article article : articles.getContent()) {
            System.out.println(article);
        }
    }
    //复合查询
    @Test
    public void findByTitleAndContent(){
        String title="搜索";
        String content="xxx";
//        List<Article> articles = articleService.findByTitleAndContent(title,content);
        List<Article> articles = articleService.findByTitleOrContent(title,content);
        for (Article article : articles) {
            System.out.println(article);
        }
    }

提醒一下，不要轻易用findAll方法，因为会把所有的结果加载到内存，让内存一下就爆炸了。一般还是用findByPage

service

public interface ArticleService {
    void save(Article article);

    void update(Article article);

    void delete(Article article);

    Article findById(int i);

    Iterable<Article> findAll();

    Page<Article> findAll(int currentPage, int size);

    List<Article> findByTitleAndContent(String title, String content);

    List<Article> findByTitleOrContent(String title, String content);
}

serviceImpl

@Service
public class ArticleServiceImpl implements ArticleService {

    @Autowired
    ArticleRepository articleRepository;

    public void save(Article article) {
        articleRepository.save(article);
    }

    public void update(Article article) {
        articleRepository.save(article);
    }

    public void delete(Article article) {
        articleRepository.delete(article);
    }

    public Article findById(int id) {
        Optional<Article> articleOptional = articleRepository.findById(id);
        return articleOptional.get();
    }

    public Iterable<Article> findAll() {
        return articleRepository.findAll();
    }

    public Page<Article> findAll(int currentPage, int size) {
        Pageable pageable = PageRequest.of(currentPage, size);
        return articleRepository.findAll(pageable);
    }

    @Override
    public List<Article> findByTitleAndContent(String title, String content) {
        return articleRepository.findByTitleAndContent(title,content);
    }
    @Override
    public List<Article> findByTitleOrContent(String title, String content) {
        return articleRepository.findByTitleOrContent(title,content);
    }
}

其中Optional类是java8新增的一个基本数据类型，为了方便我们不再判断返回来的对象是不是空对象

dao

public interface ArticleRepository extends ElasticsearchRepository<Article,Integer> {

    //select * form article where title=xx and content = xxx
    List<Article> findByTitleAndContent(String title,String content);

    List<Article> findByTitleOrContent(String title, String content);
}

常用查询命名规则

关键字	命名规则	解释	示例
and	findByField1AndField2	根据Field1和Field2获得数据	findByTitleAndContent
or	findByField1OrField2	根据Field1或Field2获得数据	findByTitleOrContent
is	findByField	根据Field获得数据	findByTitle
not	findByFieldNot	根据Field获得补集数据	findByTitleNot
between	findByFieldBetween	获得指定范围的数据	findByPriceBetween
lessThanEqual	findByFieldLessThan	获得小于等于指定值的数据	findByPriceLessThan

复合查询时使用以上规则

原生查询

// 高亮查询,term查询和queryString查询
//原生查询
@Test
public void nativeQuery(){
    // 原生查询的对象
    NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
    queryBuilder.withQuery(QueryBuilders.termQuery("title","搜索"));//设置查询方式
    queryBuilder.withPageable(PageRequest.of(0,5));//设置分页
    //queryBuilder.withHighlightFields()//高亮查询
    List<Article> articles = elasticsearchTemplate.queryForList(queryBuilder.build(), Article.class);

    for (Article article : articles) {
        System.out.println(article);
    }
}