ElasticSearch_扩展

java代码操作索引和mapping

导入依赖

<?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.Eleganise</groupId><artifactId>ElasticSearch_day2</artifactId><version>1.0-SNAPSHOT</version><dependencies><!--elasticsearch的客户端依赖--><dependency><groupId>org.elasticsearch.client</groupId><artifactId>transport</artifactId><version>6.2.4</version></dependency><!--测试依赖--><dependency><groupId>junit</groupId><artifactId>junit</artifactId><version>4.13-beta-2</version></dependency></dependencies></project>

创建索引

    private String ip = "127.0.0.1";private int port = 9300;private TransportClient transportClient = null;/*** 创建TransportClient对象用来连接服务端** @throws UnknownHostException*/@Beforepublic void init() throws UnknownHostException {transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName(ip), port));}/*** 关闭连接*/@Afterpublic void end() {transportClient.close();}/*** 单独创建索引*/@Testpublic void createTest() {//获得管理权限,由客户端发送到服务端去执行CreateIndexResponse response = transportClient.admin().indices().prepareCreate("blog2").get();//输出返回值System.out.println(response.isShardsAcknowledged());}

在head-master查看索引，注意这种方式只会创建索引，并不会创建mapping

删除索引

    /*** 删除索引*/@Testpublic void deleteTest() {//使用管理权限删除索引//第一种方式DeleteIndexResponse response = transportClient.admin().indices().prepareDelete("blog").get();//第二种方式(推荐第二种)//transportClient.admin().indices().delete(new DeleteIndexRequest("blog1"));System.out.println(response.isAcknowledged());}

创建Mapping

    /*** 为文档中的字段设定如何索引和搜索*/@Testpublic void createMapping() throws ExecutionException, InterruptedException, IOException {//判断当前要创建的索引是否存在IndicesExistsResponse response = transportClient.admin().indices().exists(new IndicesExistsRequest("blog")).get();//如果当前索引不存在if (!response.isExists()) {//创建索引CreateIndexResponse createIndexResponse = transportClient.admin().indices().prepareCreate("blog").get();//返回结果System.out.println(createIndexResponse.isShardsAcknowledged());}//创建Mapping中的内容//利用xContentBuilder构建json数据XContentBuilder xContentBuilder = XContentFactory.jsonBuilder().startObject().startObject("article").startObject("properties")//设置字段id.startObject("id").field("type", "long").endObject()//设置字段title.startObject("title").field("type", "text")//使用text类型,会对字段的内容进行分词和索引.field("store", "true")//是否进行索引的存储.field("analyzer", "ik_max_word")//设置分词器.endObject()//设置字段content.startObject("content").field("type", "text")//使用text类型,会对字段的内容进行分词和索引.field("store", "false")//是否进行索引的存储.field("analyzer", "ik_max_word")//设置分词器.endObject().endObject().endObject().endObject();//把Mapping信息构造成request请求PutMappingRequest mappingRequest = Requests.putMappingRequest("blog").type("article").source(xContentBuilder);//使用客户端发送mapping信息到服务端PutMappingResponse putMappingResponse = transportClient.admin().indices().putMapping(mappingRequest).get();//返回结果System.out.println(putMappingResponse.isAcknowledged());}

在head-master查看，索引下的mapping中有内容了

java代码操作文档

创建文档

    /*** 创建文档*/@Testpublic void createDoc() {//创建一个mapMap<String, Object> map = new HashMap<String, Object>();map.put("id", 1l);map.put("title", "谷歌的大神加盟数字地球，真他妈的扯");map.put("content", "扯到蛋了吧!!!");//添加数据并发送到服务器IndexResponse response = transportClient.prepareIndex("blog", "article", "1").setSource(map).get();//返回结果System.out.println(response.status());}

java代码查询文档（了解）

词条查询

    /*** 词条查询*/@Testpublic void searchTest() {//设置查询的索引,类型,词条和查询方式SearchResponse response = transportClient.prepareSearch("blog").setTypes("article").setQuery(QueryBuilders.termQuery("title", "百度")).get();//返回结果System.out.println(response);//获取所有命中SearchHits hits = response.getHits();for (SearchHit hit : hits) {//获取每个命中的对象以字符串的形式String sourceAsString = hit.getSourceAsString();//输出字符串System.out.println(sourceAsString);}}

分页查询和排序

    /*** 分页查询* 排序查询*/@Testpublic void searchPage() {设置查询的索引,类型,词条和查询方式SearchRequestBuilder requestBuilder = transportClient.prepareSearch("blog").setTypes("article").setQuery(QueryBuilders.termQuery("title", "大神"));//每页显示条数requestBuilder.setSize(2);//从第几条开始显示requestBuilder.setFrom(0);//提交查询SearchResponse response = requestBuilder.get();//返回结果System.out.println(response);//获取所有命中SearchHits hits = response.getHits();for (SearchHit hit : hits) {//获取每个命中的对象以字符串的形式String sourceAsString = hit.getSourceAsString();//输出字符串System.out.println(sourceAsString);}}

高亮

在进行关键字搜索时，搜索出的内容中的关键字会显示不同的颜色，称之为高亮 。

通过开发者工具查看高亮数据的html代码实现 ：

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

java代码如下：

    /*** 处理高亮*/@Testpublic void hightLight() {SearchRequestBuilder requestBuilder = transportClient.prepareSearch("blog").setTypes("article").setQuery(QueryBuilders.termQuery("title", "大神"));//设置高亮构造器HighlightBuilder highlightBuilder = new HighlightBuilder();highlightBuilder.preTags("<span style = color:red>");highlightBuilder.field("title");highlightBuilder.postTags("</span>");//将高亮构造器添加到Builder里requestBuilder.highlighter(highlightBuilder);//提交搜索,返回结果SearchResponse response = requestBuilder.get();//获取所有命中SearchHits hits = response.getHits();//打印所有命中数System.out.println(hits.totalHits);for (SearchHit hit : hits) {//返回的是原始内容,json格式System.out.println(hit.getSourceAsString());//返回的是高亮内容Map<String, HighlightField> highlightFields = hit.getHighlightFields();//获取所有的高亮内容,并拼接标签Text[] titles = highlightFields.get("title").getFragments();for (Text title : titles) {//输出内容System.out.println(title.toString());}}}

总代码

package com.Eleganise.Demo;import org.elasticsearch.action.admin.indices.create.CreateIndexResponse;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexResponse;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsResponse;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequest;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingResponse;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.client.Requests;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.common.xcontent.XContentFactory;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.junit.After;
import org.junit.Before;
import org.junit.Test;import javax.swing.text.Highlighter;
import java.io.IOException;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ExecutionException;public class MyTest {private String ip = "127.0.0.1";private int port = 9300;private TransportClient transportClient = null;/*** 创建TransportClient对象用来连接服务端** @throws UnknownHostException*/@Beforepublic void init() throws UnknownHostException {transportClient = new PreBuiltTransportClient(Settings.EMPTY).addTransportAddress(new TransportAddress(InetAddress.getByName(ip), port));}/*** 关闭连接*/@Afterpublic void end() {transportClient.close();}/*** 单独创建索引*/@Testpublic void createTest() {//获得管理权限,由客户端发送到服务端去执行CreateIndexResponse response = transportClient.admin().indices().prepareCreate("blog2").get();//输出返回值System.out.println(response.isShardsAcknowledged());}/*** 删除索引*/@Testpublic void deleteTest() {//使用管理权限删除索引//第一种方式DeleteIndexResponse response = transportClient.admin().indices().prepareDelete("blog").get();//第二种方式(推荐第二种)//transportClient.admin().indices().delete(new DeleteIndexRequest("blog1"));System.out.println(response.isAcknowledged());}/*** 为文档中的字段设定如何索引和搜索*/@Testpublic void createMapping() throws ExecutionException, InterruptedException, IOException {//判断当前要创建的索引是否存在IndicesExistsResponse response = transportClient.admin().indices().exists(new IndicesExistsRequest("blog")).get();//如果当前索引不存在if (!response.isExists()) {//创建索引CreateIndexResponse createIndexResponse = transportClient.admin().indices().prepareCreate("blog").get();//返回结果System.out.println(createIndexResponse.isShardsAcknowledged());}//创建Mapping中的内容//利用xContentBuilder构建json数据XContentBuilder xContentBuilder = XContentFactory.jsonBuilder().startObject().startObject("article").startObject("properties")//设置字段id.startObject("id").field("type", "long").endObject()//设置字段title.startObject("title").field("type", "text")//使用text类型,会对字段的内容进行分词和索引.field("store", "true")//是否进行索引的存储.field("analyzer", "ik_max_word")//设置分词器.endObject()//设置字段content.startObject("content").field("type", "text")//使用text类型,会对字段的内容进行分词和索引.field("store", "false")//是否进行索引的存储.field("analyzer", "ik_max_word")//设置分词器.endObject().endObject().endObject().endObject();//把Mapping信息构造成request请求PutMappingRequest mappingRequest = Requests.putMappingRequest("blog").type("article").source(xContentBuilder);//使用客户端发送mapping信息到服务端PutMappingResponse putMappingResponse = transportClient.admin().indices().putMapping(mappingRequest).get();//返回结果System.out.println(putMappingResponse.isAcknowledged());}/*** 创建文档*/@Testpublic void createDoc() {//创建一个mapMap<String, Object> map = new HashMap<String, Object>();map.put("id", 1l);map.put("title", "谷歌的大神加盟数字地球，真他妈的扯");map.put("content", "扯到蛋了吧!!!");//添加数据并发送到服务器IndexResponse response = transportClient.prepareIndex("blog", "article", "1").setSource(map).get();//返回结果System.out.println(response.status());}/*** 词条查询*/@Testpublic void searchTest() {//设置查询的索引,类型,词条和查询方式SearchResponse response = transportClient.prepareSearch("blog").setTypes("article").setQuery(QueryBuilders.termQuery("title", "百度")).get();//返回结果System.out.println(response);//获取所有命中SearchHits hits = response.getHits();for (SearchHit hit : hits) {//获取每个命中的对象以字符串的形式String sourceAsString = hit.getSourceAsString();//输出字符串System.out.println(sourceAsString);}}/*** 分页查询* 排序查询*/@Testpublic void searchPage() {设置查询的索引,类型,词条和查询方式SearchRequestBuilder requestBuilder = transportClient.prepareSearch("blog").setTypes("article").setQuery(QueryBuilders.termQuery("title", "大神"));//每页显示条数requestBuilder.setSize(2);//从第几条开始显示requestBuilder.setFrom(0);//提交查询SearchResponse response = requestBuilder.get();//返回结果System.out.println(response);//获取所有命中SearchHits hits = response.getHits();for (SearchHit hit : hits) {//获取每个命中的对象以字符串的形式String sourceAsString = hit.getSourceAsString();//输出字符串System.out.println(sourceAsString);}}/*** 处理高亮*/@Testpublic void hightLight() {SearchRequestBuilder requestBuilder = transportClient.prepareSearch("blog").setTypes("article").setQuery(QueryBuilders.termQuery("title", "大神"));//设置高亮构造器HighlightBuilder highlightBuilder = new HighlightBuilder();highlightBuilder.preTags("<span style = color:red>");highlightBuilder.field("title");highlightBuilder.postTags("</span>");//将高亮构造器添加到Builder里requestBuilder.highlighter(highlightBuilder);//提交搜索,返回结果SearchResponse response = requestBuilder.get();//获取所有命中SearchHits hits = response.getHits();//打印所有命中数System.out.println(hits.totalHits);for (SearchHit hit : hits) {//返回的是原始内容,json格式System.out.println(hit.getSourceAsString());//返回的是高亮内容Map<String, HighlightField> highlightFields = hit.getHighlightFields();//获取所有的高亮内容,并拼接标签Text[] titles = highlightFields.get("title").getFragments();for (Text title : titles) {//输出内容System.out.println(title.toString());}}}}

安装kibana

什么是Kibana？

Kibana是一个基于Node.js的Elasticsearch索引库数据统计工具，可以利用Elasticsearch的聚合功能，生成各种图表，如柱形图，线状图，饼图等。

而且还提供了操作Elasticsearch索引数据的控制台，并且提供了一定的API提示，非常有利于我们学习Elasticsearch的语法。

安装

因为Kibana依赖于node，需要在windows下先安装Node.js，双击运行课前资料提供的node.js的安装包：

一路下一步即可安装成功，然后在任意黑窗口输入名：

node -v

可以查看到node版本,想要运行kibana必须node -v，如下：

然后安装kibana，最新版本与elasticsearch保持一致，也是6.2.4

解压即可：

配置运行

配置

进入安装目录下的config目录，修改kibana.yml文件(默认就是,不用动)：

修改elasticsearch服务器的地址：

elasticsearch.url: "http://127.0.0.1:9200"

运行

进入安装目录下的bin目录：

双击运行：

发现kibana的监听端口是5601

我们访问：http://127.0.0.1:5601

控制台

选择左侧的DevTools菜单，即可进入控制台页面：

在页面右侧，我们就可以输入请求，访问Elasticsearch了。

RestApi 创建索引库

语法

Elasticsearch采用Rest风格API，其API就是一次http请求，你可以用任何工具发起http请求

创建索引的请求格式：

• 请求方式：PUT

• 请求路径：/索引库名

• 请求参数：json格式：

  {"settings": {"属性名": "属性值"}
  }
  

  settings：就是索引库设置，其中可以定义索引库的各种属性，目前我们可以不设置，都走默认。

可以看到索引创建成功了。

使用kibana创建索引

kibana的控制台，可以对http请求进行简化，示例：

省去了elasticsearch的服务器地址，而且还有语法提示，非常舒服。

查看索引库

语法

Get请求可以帮我们查看索引信息，格式：

GET /索引库名

删除索引库

删除索引使用DELETE请求

语法

DELETE /索引库名

示例

再次查看eleganise2：

当然，我们也可以用HEAD请求，查看索引是否存在：

对类型和映射操作

有了索引库，等于有了数据库中的database。接下来就需要索引库中的类型了，也就是数据库中的表。创建数据库表需要设置字段约束，索引库也一样，在创建索引库的类型时，需要知道这个类型下有哪些字段，每个字段有哪些约束信息，这就叫做字段映射(mapping)

字段的约束我们在学习Lucene中我们都见到过，包括到不限于：

• 字段的数据类型
• 是否要存储
• 是否要索引
• 是否分词
• 分词器是什么

我们一起来看下创建的语法。

创建字段映射

语法

请求方式依然是PUT

PUT /索引库名/_mapping/类型名称
{"properties": {"字段名": {"type": "类型","index": true，"store": true，"analyzer": "分词器"}}
}

• 类型名称：就是前面将的type的概念，类似于数据库中的表
  字段名：任意填写，下面指定许多属性，例如：
  • type：类型，可以是text、long、short、date、integer、object等
  • index：是否索引，默认为true
  • store：是否存储，默认为false
  • analyzer：分词器，这里的ik_max_word即使用ik分词器

示例

发起请求(这种创建mapping的方式,必要要有索引才能创建)：

PUT eleganise/_mapping/goods
{"properties": {"title": {"type": "text","analyzer": "ik_max_word"},"images": {"type": "keyword","index": "false"},"price": {"type": "float"}}
}

响应结果：

{"acknowledged": true
}

上述案例中，就给eleganise这个索引库添加了一个名为goods的类型，并且在类型中设置了3个字段：

• title：商品标题
• images：商品图片
• price：商品价格

并且给这些字段设置了一些属性，至于这些属性对应的含义，我们在后续会详细介绍。

查看映射关系

语法：

GET /索引库名/_mapping

查看某个索引库中的所有类型的映射。如果要查看某个类型映射，可以再路径后面跟上类型名称。即：

GET /索引库名/_mapping/映射名

示例：

GET /eleganise/_mapping

响应：

{"eleganise": {"mappings": {"goods": {"properties": {"images": {"type": "keyword","index": false},"price": {"type": "float"},"title": {"type": "text","analyzer": "ik_max_word"}}}}}
}

映射属性详解

1）type

Elasticsearch中支持的数据类型非常丰富：

我们说几个关键的：

• String类型，又分两种：

  • text：可分词，不可参与聚合
  • keyword：不可分词，数据会作为完整字段进行匹配，可以参与聚合

• Numerical：数值类型，分两类

  • 基本数据类型：long、interger、short、byte、double、float、half_float
  • 浮点数的高精度类型：scaled_float
    • 需要指定一个精度因子，比如10或100。elasticsearch会把真实值乘以这个因子后存储，取出时再还原。

• Date：日期类型

  elasticsearch可以对日期格式化为字符串存储，但是建议我们存储为毫秒值，存储为long，节省空间。

• Array：数组类型

  • 进行匹配时，任意一个元素满足，都认为满足
  • 排序时，如果升序则用数组中的最小值来排序，如果降序则用数组中的最大值来排序

• Object：对象

{name:"Jack",age:21,girl:{name: "Rose",age:21}
}

如果存储到索引库的是对象类型，例如上面的girl，会把girl编程两个字段：girl.name和girl.age

2）index

index影响字段的索引情况。

• true：字段会被索引，则可以用来进行搜索过滤。默认值就是true
• false：字段不会被索引，不能用来搜索

index的默认值就是true，也就是说你不进行任何配置，所有字段都会被索引。

但是有些字段是我们不希望被索引的，比如商品的图片信息，就需要手动设置index为false。

3）store

是否将数据进行额外存储。

在学习lucene时，我们知道如果一个字段的store设置为false，那么在文档列表中就不会有这个字段的值，用户的搜索结果中不会显示出来。

但是在Elasticsearch中，即便store设置为false，也可以搜索到结果。

原因是Elasticsearch在创建文档索引时，会将文档中的原始数据备份，保存到一个叫做_source的属性中。而且我们可以通过过滤_source来选择哪些要显示，哪些不显示。

而如果设置store为true，就会在_source以外额外存储一份数据，多余，因此一般我们都会将store设置为false，事实上，store的默认值就是false。

4）boost

权重，新增数据时，可以指定该数据的权重，权重越高，得分越高，排名越靠前。

一次创建索引库和类型

刚才 的案例中我们是把创建索引库和类型分开来做，其实也可以在创建索引库的同时，直接制定索引库中的类型，基本语法：

put /索引库名
{"settings":{"索引库属性名":"索引库属性值"},"mappings":{"类型名":{"properties":{"字段名":{"映射属性名":"映射属性值"}}}}
}

来试一下吧：

PUT /eleganise2
{"settings": {}, "mappings": {"goods": {"properties": {"images": {"type": "keyword","index": false},"price": {"type": "long"},"title": {"type": "text","analyzer": "ik_max_word"}}}}
}

结果：

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

然后我们查看下映射：

对文档操作

文档，即索引库中某个类型下的数据，会根据规则创建索引，将来用来搜索。可以类比做数据库中的每一行数据。

新增文档

新增并随机生成id

通过POST请求，可以向一个已经存在的索引库中添加文档数据。

语法：

POST /索引库名/类型名
{"key":"value"
}

示例：

POST /eleganise/goods/
{"title":"小米手机","images":"http://image.eleganise.com/12479122.jpg","price":2699.00
}

响应：

{"_index": "eleganise","_type": "goods","_id": "bej3m24BYouInEx43wdc","_version": 1,"result": "created","_shards": {"total": 2,"successful": 1,"failed": 0},"_seq_no": 0,"_primary_term": 1
}

可以看到结果显示为：created，应该是创建成功了。

另外，需要注意的是，在响应结果中有个_id字段，这个就是这条文档数据的唯一标示，以后的增删改查都依赖这个id作为唯一标示。

可以看到id的值为：bej3m24BYouInEx43wdc,这里我们新增时没有指定id，所以是ES帮我们随机生成的id。

查看文档

根据rest风格，新增是post，查询应该是get，不过查询一般都需要条件，这里我们把刚刚生成数据的id带上。

通过kibana查看数据：

GET /eleganise/goods/bej3m24BYouInEx43wdc

查看结果：

{"_index": "eleganise","_type": "goods","_id": "bej3m24BYouInEx43wdc","_version": 1,"found": true,"_source": {"title": "小米手机","images": "http://image.eleganise.com/12479122.jpg","price": 2699}
}

• _source：源文档信息，所有的数据都在里面。
• _id：这条文档的唯一标示

新增文档并自定义id

如果我们想要自己新增的时候指定id，可以这么做：

POST /索引库名/类型/id值
{...
}

示例：

POST /eleganise/goods/2
{"title":"大米手机","images":"http://image.eleganise.com/12479122.jpg","price":2899.00
}

得到的数据：

{"_index": "eleganise","_type": "goods","_id": "2","_version": 1,"result": "created","_shards": {"total": 2,"successful": 1,"failed": 0},"_seq_no": 0,"_primary_term": 1
}

修改数据

把刚才新增的请求方式改为PUT(POST也行)，就是修改了。不过修改必须指定id，

• id对应文档存在，则修改
• id对应文档不存在，则新增

比如，我们把使用id为4，不存在，则应该是新增：

PUT /eleganise/goods/4
{"title":"大米手机","images":"http://image.eleganise.com/12479122.jpg","price":9459.00
}

结果：

{"_index": "eleganise","_type": "goods","_id": "4","_version": 1,"result": "created","_shards": {"total": 2,"successful": 1,"failed": 0},"_seq_no": 6,"_primary_term": 1
}

可以看到是created，是新增。

我们再次执行刚才的请求，不过把数据改一下：

PUT /eleganise/goods/4
{"title":"超大米手机","images":"http://image.eleganise.com/12479122.jpg","price":329900,"stock": 100,"saleable":true
}

查看结果：

{"_index": "eleganise","_type": "goods","_id": "4","_version": 2,"result": "updated","_shards": {"total": 2,"successful": 1,"failed": 0},"_seq_no": 7,"_primary_term": 1
}

可以看到结果是：updated，显然是更新数据

删除数据

删除使用DELETE请求，同样，需要根据id进行删除：

语法

DELETE /索引库名/类型名/id值

示例：

DELETE /eleganise/goods/3

智能判断

刚刚我们在新增数据时，添加的字段都是提前在类型中定义过的，如果我们添加的字段并没有提前定义过，能够成功吗？

事实上Elasticsearch非常智能，你不需要给索引库设置任何mapping映射，它也可以根据你输入的数据来判断类型，动态添加数据映射。

测试一下：

POST /eleganise/goods/3
{"title":"超大米手机","images":"http://image.eleganise.com/12479122.jpg","price":329900,"stock": 200,"saleable":true,"subTitle":"哈哈"
}

我们额外添加了stock库存，saleable是否上架，subtitle副标题、3个字段。

来看结果：

{"_index": "eleganise","_type": "goods","_id": "3","_version": 1,"result": "created","_shards": {"total": 2,"successful": 1,"failed": 0},"_seq_no": 4,"_primary_term": 1
}

成功了！在看下索引库的映射关系:

{"eleganise": {"mappings": {"goods": {"properties": {"images": {"type": "keyword","index": false},"price": {"type": "float"},"saleable": {"type": "boolean"},"stock": {"type": "long"},"subTitle": {"type": "text","fields": {"keyword": {"type": "keyword","ignore_above": 256}}},"title": {"type": "text","analyzer": "ik_max_word"}}}}}
}

stock、saleable、subtitle都被成功映射了。

subtitle是String类型数据，ES无法智能判断，它就会存入两个字段。例如：

• subtitle：text类型
• subtitle.keyword：keyword类型

这种智能映射，底层原理是动态模板映射，如果我们想修改这种智能映射的规则，其实只要修改动态模板即可！

动态映射模板

动态模板的语法：

1）模板名称，随便起

2）匹配条件，凡是符合条件的未定义字段，都会按照这个规则来映射

3）映射规则，匹配成功后的映射规则

举例，我们可以把所有未映射的string类型数据自动映射为keyword类型：

PUT eleganise3
{"mappings": {"goods": {"properties": {"title": {"type": "text","analyzer": "ik_max_word"}},"dynamic_templates": [{"strings": {"match_mapping_type": "string","mapping": {"type": "keyword"}}}]}}
}

在这个案例中，我们把做了两个映射配置：

• title字段：统一映射为text类型，并制定分词器
• 其它字段：只要是string类型，统一都处理为keyword类型。

这样，未知的string类型数据就不会被映射为text和keyword并存，而是统一以keyword来处理！

我们试试看新增一个数据：

POST /eleganise3/goods/1
{"title":"超大米手机","images":"http://eleganise.leyou.com/12479122.jpg","price":3299.00
}

我们只对title做了配置，现在来看看images和price会被映射为什么类型呢：

GET /eleganise3/_mapping

结果：

{"eleganise3": {"mappings": {"goods": {"dynamic_templates": [{"strings": {"match_mapping_type": "string","mapping": {"type": "keyword"}}}],"properties": {"images": {"type": "keyword"},"price": {"type": "float"},"title": {"type": "text","analyzer": "ik_max_word"}}}}}
}

可以看到images被映射成了keyword，而非之前的text和keyword并存，说明我们的动态模板生效了！

实现查询

我们从4块来讲查询：

• 基本查询
• _source过滤
• 结果过滤
• 高级查询
• 排序

基本查询

基本语法

GET /索引库名/_search
{"query":{"查询类型":{"查询条件":"查询条件值"}}
}

这里的query代表一个查询对象，里面可以有不同的查询属性

• 查询类型：
  • 例如：match_all， match，term ， range 等等
• 查询条件：查询条件会根据类型的不同，写法也有差异，后面详细讲解

查询所有（match_all)

示例：

GET /eleganise/_search
{"query":{"match_all": {}}
}

• query：代表查询对象
• match_all：代表查询所有

结果：

{"took": 2,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 2,"max_score": 1,"hits": [{"_index": "eleganise","_type": "goods","_id": "bej3m24BYouInEx43wdc","_score": 1,"_source": {"title": "小米手机","images": "http://image.eleganise.com/12479122.jpg","price": 2699}},{"_index": "eleganise","_type": "goods","_id": "3","_score": 1,"_source": {"title": "超大米手机","images": "http://image.eleganise.com/12479122.jpg","price": 329900,"stock": 200,"saleable": true,"subTitle": "哈哈"}}]}
}

• took：查询花费时间，单位是毫秒
• time_out：是否超时
• _shards：分片信息
• hits：搜索结果总览对象
  • total：搜索到的总条数
  • max_score：所有结果中文档得分的最高分
  • hits：搜索结果的文档对象数组，每个元素是一条搜索到的文档信息
    • _index：索引库
    • _type：文档类型
    • _id：文档id
    • _score：文档得分
    • _source：文档的源数据

匹配查询（match）

我们先加入一条数据，便于测试：

PUT /eleganise/goods/2
{"title":"小米电视4A","images":"http://image.eleganise.com/12479122.jpg","price":3899.00
}

现在，索引库中有2部手机，1台电视：

• or关系

match类型查询，会把查询条件进行分词，然后进行查询,多个词条之间是or的关系

GET /eleganise/_search
{"query":{"match":{"title":"小米电视"}}
}

结果：

{"took": 79,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 2,"max_score": 0.7549128,"hits": [{"_index": "eleganise","_type": "goods","_id": "bej3m24BYouInEx43wdc","_score": 0.7549128,"_source": {"title": "小米手机","images": "http://image.eleganise.com/12479122.jpg","price": 2699}},{"_index": "eleganise","_type": "goods","_id": "2","_score": 0.5753642,"_source": {"title": "小米电视4A","images": "http://image.eleganise.com/12479122.jpg","price": 3899}}]}
}

在上面的案例中，不仅会查询到电视，而且与小米相关的都会查询到，多个词之间是or的关系。

• and关系

某些情况下，我们需要更精确查找，我们希望这个关系变成and，可以这样做：

GET /eleganise/goods/_search
{"query": {"match": {"title": {"query": "小米电视","operator": "and"}}}
}

结果：

本例中，只有同时包含小米和电视的词条才会被搜索到。

词条匹配(term)

term 查询被用于精确值 匹配，这些精确值可能是数字、时间、布尔或者那些未分词的字符串

GET /eleganise/_search
{"query":{"term":{"price":3899}}
}

结果：

{"took": 1,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 1,"max_score": 1,"hits": [{"_index": "eleganise","_type": "goods","_id": "2","_score": 1,"_source": {"title": "小米电视4A","images": "http://image.eleganise.com/12479122.jpg","price": 3899}}]}
}

布尔组合（bool)

bool把各种其它查询通过must（与）、must_not（非）、should（或）的方式进行组合

GET /eleganise/_search
{"query":{"bool":{"must":     { "match": { "title": "手机" }},"must_not": { "match": { "title": "电视" }},"should":   { "match": { "title": "小米" }}}}
}

结果：

{"took": 4,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 2,"max_score": 0.95348084,"hits": [{"_index": "eleganise","_type": "goods","_id": "bej3m24BYouInEx43wdc","_score": 0.95348084,"_source": {"title": "小米手机","images": "http://image.eleganise.com/12479122.jpg","price": 2699}},{"_index": "eleganise","_type": "goods","_id": "3","_score": 0.16853254,"_source": {"title": "超大米手机","images": "http://image.eleganise.com/12479122.jpg","price": 329900,"stock": 200,"saleable": true,"subTitle": "哈哈"}}]}
}

范围查询(range)

range 查询找出那些落在指定区间内的数字或者时间

GET /eleganise/_search
{"query":{"range": {"price": {"gte":  1000.0,"lt":   2800.00}}}
}

range查询允许以下字符：

操作符	说明
gt	大于
gte	大于等于
lt	小于
lte	小于等于

模糊查询(fuzzy)

我们新增一个商品：

POST /eleganise/goods/4
{"title":"apple手机","images":"http://image.eleganise.com/12479122.jpg","price":6899.00
}

fuzzy 查询是 term 查询的模糊等价。它允许用户搜索词条与实际词条的拼写出现偏差，但是偏差的编辑距离不得超过2：

GET /eleganise/_search
{"query": {"fuzzy": {"title": "appla"}}
}

上面的查询，也能查询到apple手机

我们可以通过fuzziness来指定允许的编辑距离：

GET /eleganise/_search
{"query": {"fuzzy": {"title": {"value":"appla","fuzziness":1}}}
}

结果过滤

默认情况下，elasticsearch在搜索的结果中，会把文档中保存在_source的所有字段都返回。

如果我们只想获取其中的部分字段，我们可以添加_source的过滤

直接指定字段

示例：

GET /eleganise/_search
{"_source": ["title","price"],"query": {"match_all": {}}
}

返回的结果：

{"took": 3,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 4,"max_score": 1,"hits": [{"_index": "eleganise","_type": "goods","_id": "2","_score": 1,"_source": {"price": 3899,"title": "小米电视4A"}},{"_index": "eleganise","_type": "goods","_id": "4","_score": 1,"_source": {"price": 6899,"title": "apple手机"}},{"_index": "eleganise","_type": "goods","_id": "bej3m24BYouInEx43wdc","_score": 1,"_source": {"price": 2699,"title": "小米手机"}},{"_index": "eleganise","_type": "goods","_id": "3","_score": 1,"_source": {"price": 329900,"title": "超大米手机"}}]}
}

5.2.2.指定includes和excludes

我们也可以通过：

• includes：来指定想要显示的字段
• excludes：来指定不想要显示的字段

二者都是可选的。

示例：

GET /eleganise/_search
{"_source": {"includes":["title","price"]},"query": {"term": {"price": 2699}}
}

与下面的结果将是一样的：

GET /eleganise/_search
{"_source": {"excludes": ["images"]},"query": {"term": {"price": 2699}}
}

过滤(filter)

条件查询中进行过滤

Bool查询现在包括四种子句，must，filter,should,must_not

filter先判断是否满足查询条件，如果不满足，会缓存查询过程（记录该文档不满足结果）；满足的话，就直接缓存结果，filter快在两个方面：

• 1 对结果进行缓存
• 2 避免计算分值

bool查询的使用

Bool查询对应Lucene中的BooleanQuery，它由一个或者多个子句组成，每个子句都有特定的类型。

• must

返回的文档必须满足must子句的条件，并且参与计算分值

• filter

返回的文档必须满足filter子句的条件。但是不会像Must一样，参与计算分值

• should

返回的文档可能满足should子句的条件。在一个Bool查询中，如果没有must或者filter，有一个或者多个should子句，那么只要满足一个就可以返回。minimum_should_match参数定义了至少满足几个子句

• must_nout

返回的文档必须不满足must_not定义的条件

所有的查询都会影响到文档的评分及排名。如果我们需要在查询结果中进行过滤，并且不希望过滤条件影响评分，那么就不要把过滤条件作为查询条件来用。而是使用filter方式：

GET /eleganise/_search
{"query":{"bool":{"must":{ "match": { "title": "小米手机" }},"filter":{"range":{"price":{"gt":2000.00,"lt":3800.00}}}}}
}

无查询条件，直接过滤

如果一次查询只有过滤，没有查询条件，不希望进行评分，我们可以使用constant_score取代只有 filter 语句的 bool 查询。在性能上是完全相同的，但对于提高查询简洁性和清晰度有很大帮助。

GET /eleganise/_search
{"query":{"constant_score":   {"filter": {"range":{"price":{"gt":2000.00,"lt":3000.00}}}}}
}

排序

单字段排序

sort 可以让我们按照不同的字段进行排序，并且通过order指定排序的方式

GET /eleganise/_search
{"query": {"match": {"title": "小米手机"}},"sort": [{"price": {"order": "desc"}}]
}

多字段排序

假定我们想要结合使用 price和 _score（得分） 进行查询，并且匹配的结果首先按照价格排序，然后按照相关性得分排序：

GET /eleganise/_search
{"query":{"bool":{"must":{ "match": { "title": "小米手机" }},"filter":{"range":{"price":{"gt":200,"lt":300000}}}}},"sort": [{ "price": { "order": "desc" }},{ "_score": { "order": "desc" }}]
}

分页

elasticsearch的分页与mysql数据库非常相似，都是指定两个值：

• from：开始位置
• size：每页大小

GET /eleganise/_search
{"query": {"match_all": {}},"sort": [{"price": {"order": "asc"}}],"from": 0,"size": 2
}

结果：

{"took": 1,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 4,"max_score": null,"hits": [{"_index": "eleganise","_type": "goods","_id": "bej3m24BYouInEx43wdc","_score": null,"_source": {"title": "小米手机","images": "http://image.eleganise.com/12479122.jpg","price": 2699},"sort": [2699]},{"_index": "eleganise","_type": "goods","_id": "2","_score": null,"_source": {"title": "小米电视4A","images": "http://image.eleganise.com/12479122.jpg","price": 3899},"sort": [3899]}]}
}

高亮

高亮原理：

• 服务端搜索数据，得到搜索结果
• 把搜索结果中，搜索关键字都加上约定好的标签
• 前端页面提前写好标签的CSS样式，即可高亮

elasticsearch中实现高亮的语法比较简单：

GET /eleganise/_search
{"query": {"match": {"title": "手机"}},"highlight": {"pre_tags": "<em>","post_tags": "</em>", "fields": {"title": {}}}
}

在使用match查询的同时，加上一个highlight属性：

• pre_tags：前置标签
• post_tags：后置标签
• fields：需要高亮的字段
  • title：这里声明title字段需要高亮，后面可以为这个字段设置特有配置，也可以空

结果：

{"took": 6,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 3,"max_score": 0.80259144,"hits": [{"_index": "eleganise","_type": "goods","_id": "4","_score": 0.80259144,"_source": {"title": "apple手机","images": "http://image.eleganise.com/12479122.jpg","price": 6899},"highlight": {"title": ["apple<em>手机</em>"]}},{"_index": "eleganise","_type": "goods","_id": "bej3m24BYouInEx43wdc","_score": 0.19856805,"_source": {"title": "小米手机","images": "http://image.eleganise.com/12479122.jpg","price": 2699},"highlight": {"title": ["小米<em>手机</em>"]}},{"_index": "eleganise","_type": "goods","_id": "3","_score": 0.16853254,"_source": {"title": "超大米手机","images": "http://image.eleganise.com/12479122.jpg","price": 329900,"stock": 200,"saleable": true,"subTitle": "哈哈"},"highlight": {"title": ["超大米<em>手机</em>"]}}]}
}

实现聚合

聚合成为aggregations

聚合可以让我们极其方便的实现对数据的统计、分析。例如：

• 什么品牌的手机最受欢迎？
• 这些手机的平均价格、最高价格、最低价格？
• 这些手机每月的销售情况如何？

实现这些统计功能的比数据库的sql要方便的多，而且查询速度非常快，可以实现近实时搜索效果。

基本概念

Elasticsearch中的聚合，包含多种类型，最常用的两种，一个叫桶，一个叫度量：

桶（bucket)

桶的作用，是按照某种方式对数据进行分组，每一组数据在ES中称为一个桶，例如我们根据国籍对人划分，可以得到中国桶、英国桶，日本桶……或者我们按照年龄段对人进行划分：0_10,1020,20_30,3040等。

Elasticsearch中提供的划分桶的方式有很多：

• Date Histogram Aggregation：根据日期阶梯分组，例如给定阶梯为周，会自动每周分为一组
• Histogram Aggregation：根据数值阶梯分组，与日期类似，需要知道分组的间隔（interval）
• Terms Aggregation：根据词条内容分组，词条内容完全匹配的为一组
• Range Aggregation：数值和日期的范围分组，指定开始和结束，然后按段分组
• ……

综上所述，我们发现bucket aggregations 只负责对数据进行分组，并不进行计算，因此往往bucket中往往会嵌套另一种聚合：metrics aggregations即度量

度量（metrics）

分组完成以后，我们一般会对组中的数据进行聚合运算，例如求平均值、最大、最小、求和等，这些在ES中称为度量

比较常用的一些度量聚合方式：

• Avg Aggregation：求平均值
• Max Aggregation：求最大值
• Min Aggregation：求最小值
• Percentiles Aggregation：求百分比
• Stats Aggregation：同时返回avg、max、min、sum、count等
• Sum Aggregation：求和
• Top hits Aggregation：求前几
• Value Count Aggregation：求总数
• ……

为了测试聚合，我们先批量导入一些数据

创建索引：

PUT /car
{"mappings": {"orders": {"properties": {"color": {"type": "keyword"},"make": {"type": "keyword"}}}}
}

注意：在ES中，需要进行聚合、排序、过滤的字段其处理方式比较特殊，因此不能被分词，必须使用keyword或数值类型。这里我们将color和make这两个文字类型的字段设置为keyword类型，这个类型不会被分词，将来就可以参与聚合

导入数据，这里是采用批处理的API，大家直接复制到kibana运行即可：

批处理的API 关键词 是：_bulk

POST /car/orders/_bulk
{ "index": {}}
{ "price" : 10000, "color" : "红", "make" : "本田", "sold" : "2014-10-28" }
{ "index": {}}
{ "price" : 20000, "color" : "红", "make" : "本田", "sold" : "2014-11-05" }
{ "index": {}}
{ "price" : 30000, "color" : "绿", "make" : "福特", "sold" : "2014-05-18" }
{ "index": {}}
{ "price" : 15000, "color" : "蓝", "make" : "丰田", "sold" : "2014-07-02" }
{ "index": {}}
{ "price" : 12000, "color" : "绿", "make" : "丰田", "sold" : "2014-08-19" }
{ "index": {}}
{ "price" : 20000, "color" : "红", "make" : "本田", "sold" : "2014-11-05" }
{ "index": {}}
{ "price" : 80000, "color" : "红", "make" : "宝马", "sold" : "2014-01-01" }
{ "index": {}}
{ "price" : 25000, "color" : "蓝", "make" : "福特", "sold" : "2014-02-12" }

聚合为桶

首先，我们按照 汽车的颜色color来划分桶，按照颜色分桶，最好是使用TermAggregation类型，按照颜色的名称来分桶。

GET /car/_search
{"size" : 0,"aggs" : { "popular_colors" : { "terms" : { "field" : "color"}}}
}

• size： 查询条数，这里设置为0，因为我们不关心搜索到的数据，只关心聚合结果，提高效率
• aggs：声明这是一个聚合查询，是aggregations的缩写
  • popular_colors：给这次聚合起一个名字，可任意指定。
    • terms：聚合的类型，这里选择terms，是根据词条内容（这里是颜色）划分
      • field：划分桶时依赖的字段

结果：

{"took": 141,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 8,"max_score": 0,"hits": []},"aggregations": {"popular_colors": {"doc_count_error_upper_bound": 0,"sum_other_doc_count": 0,"buckets": [{"key": "红","doc_count": 4},{"key": "绿","doc_count": 2},{"key": "蓝","doc_count": 2}]}}
}

• hits：查询结果为空，因为我们设置了size为0
• aggregations：聚合的结果
• popular_colors：我们定义的聚合名称
• buckets：查找到的桶，每个不同的color字段值都会形成一个桶
  • key：这个桶对应的color字段的值
  • doc_count：这个桶中的文档数量

通过聚合的结果我们发现，目前红色的小车比较畅销！

桶内度量

前面的例子告诉我们每个桶里面的文档数量，这很有用。 但通常，我们的应用需要提供更复杂的文档度量。 例如，每种颜色汽车的平均价格是多少？

因此，我们需要告诉Elasticsearch使用哪个字段，使用何种度量方式进行运算，这些信息要嵌套在桶内，度量的运算会基于桶内的文档进行

现在，我们为刚刚的聚合结果添加 求价格平均值的度量：

GET /car/_search
{"size" : 0,"aggs" : { "popular_colors" : { "terms" : { "field" : "color"},"aggs":{"avg_price": { "avg": {"field": "price" }}}}}
}

• aggs：我们在上一个aggs(popular_colors)中添加新的aggs。可见度量也是一个聚合
• avg_price：聚合的名称
• avg：度量的类型，这里是求平均值
• field：度量运算的字段

结果：

{"took": 163,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 8,"max_score": 0,"hits": []},"aggregations": {"popular_colors": {"doc_count_error_upper_bound": 0,"sum_other_doc_count": 0,"buckets": [{"key": "红","doc_count": 4,"avg_price": {"value": 32500}},{"key": "绿","doc_count": 2,"avg_price": {"value": 21000}},{"key": "蓝","doc_count": 2,"avg_price": {"value": 20000}}]}}
}

可以看到每个桶中都有自己的avg_price字段，这是度量聚合的结果

桶内嵌套桶

刚刚的案例中，我们在桶内嵌套度量运算。事实上桶不仅可以嵌套运算， 还可以再嵌套其它桶。也就是说在每个分组中，再分更多组。

比如：我们想统计每种颜色的汽车中，分别属于哪个制造商，按照make字段再进行分桶

GET /car/_search
{"size" : 0,"aggs" : { "popular_colors" : { "terms" : { "field" : "color"},"aggs":{"avg_price": { "avg": {"field": "price" }},"maker":{"terms":{"field":"make"}}}}}
}

• 原来的color桶和avg计算我们不变
• maker：在嵌套的aggs下新添一个桶，叫做maker
• terms：桶的划分类型依然是词条
• filed：这里根据make字段进行划分

部分结果：

{"took": 61,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 8,"max_score": 0,"hits": []},"aggregations": {"popular_colors": {"doc_count_error_upper_bound": 0,"sum_other_doc_count": 0,"buckets": [{"key": "红","doc_count": 4,"maker": {"doc_count_error_upper_bound": 0,"sum_other_doc_count": 0,"buckets": [{"key": "本田","doc_count": 3},{"key": "宝马","doc_count": 1}]},"avg_price": {"value": 32500}},{"key": "绿","doc_count": 2,"maker": {"doc_count_error_upper_bound": 0,"sum_other_doc_count": 0,"buckets": [{"key": "丰田","doc_count": 1},{"key": "福特","doc_count": 1}]},"avg_price": {"value": 21000}},{"key": "蓝","doc_count": 2,"maker": {"doc_count_error_upper_bound": 0,"sum_other_doc_count": 0,"buckets": [{"key": "丰田","doc_count": 1},{"key": "福特","doc_count": 1}]},"avg_price": {"value": 20000}}]}}
}

• 我们可以看到，新的聚合maker被嵌套在原来每一个color的桶中。
• 每个颜色下面都根据 make字段进行了分组
• 我们能读取到的信息：
  • 红色车共有4辆
  • 红色车的平均售价是 $32，500 美元。
  • 其中3辆是 Honda 本田制造，1辆是 BMW 宝马制造。

划分桶的其它方式

前面讲了，划分桶的方式有很多，例如：

• Date Histogram Aggregation：根据日期阶梯分组，例如给定阶梯为周，会自动每周分为一组
• Histogram Aggregation：根据数值阶梯分组，与日期类似
• Terms Aggregation：根据词条内容分组，词条内容完全匹配的为一组
• Range Aggregation：数值和日期的范围分组，指定开始和结束，然后按段分组

刚刚的案例中，我们采用的是Terms Aggregation，即根据词条划分桶。

接下来，我们再学习几个比较实用的：

6.5.1.阶梯分桶Histogram

原理：

histogram是把数值类型的字段，按照一定的阶梯大小进行分组。你需要指定一个阶梯值（interval）来划分阶梯大小。

举例：

比如你有价格字段，如果你设定interval的值为200，那么阶梯就会是这样的：

0，200，400，600，…

上面列出的是每个阶梯的key，也是区间的启点。

如果一件商品的价格是450，会落入哪个阶梯区间呢？计算公式如下：

bucket_key = Math.floor((value - offset) / interval) * interval + offset

value：就是当前数据的值，本例中是450

offset：起始偏移量，默认为0

interval：阶梯间隔，比如200

因此你得到的key = Math.floor((450 - 0) / 200) * 200 + 0 = 400

操作一下：

比如，我们对汽车的价格进行分组，指定间隔interval为5000：

GET /car/_search
{"size": 0,"aggs": {"price": {"histogram": {"field": "price","interval": 5000}}}
}

结果：

{"took": 11,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 8,"max_score": 0,"hits": []},"aggregations": {"price": {"buckets": [{"key": 10000,"doc_count": 2},{"key": 15000,"doc_count": 1},{"key": 20000,"doc_count": 2},{"key": 25000,"doc_count": 1},{"key": 30000,"doc_count": 1},{"key": 35000,"doc_count": 0},{"key": 40000,"doc_count": 0},{"key": 45000,"doc_count": 0},{"key": 50000,"doc_count": 0},{"key": 55000,"doc_count": 0},{"key": 60000,"doc_count": 0},{"key": 65000,"doc_count": 0},{"key": 70000,"doc_count": 0},{"key": 75000,"doc_count": 0},{"key": 80000,"doc_count": 1}]}}
}

你会发现，中间有大量的文档数量为0 的桶，看起来很丑。

我们可以增加一个参数min_doc_count为1，来约束最少文档数量为1，这样文档数量为0的桶会被过滤

示例：

GET /car/_search
{"size": 0,"aggs": {"price": {"histogram": {"field": "price","interval": 5000,"min_doc_count": 1}}}
}

结果：

{"took": 1,"timed_out": false,"_shards": {"total": 5,"successful": 5,"skipped": 0,"failed": 0},"hits": {"total": 8,"max_score": 0,"hits": []},"aggregations": {"price": {"buckets": [{"key": 10000,"doc_count": 2},{"key": 15000,"doc_count": 1},{"key": 20000,"doc_count": 2},{"key": 25000,"doc_count": 1},{"key": 30000,"doc_count": 1},{"key": 80000,"doc_count": 1}]}}
}

SpringDataElasticsearch

接下来我们学习Spring提供的elasticsearch组件：Spring Data Elasticsearch

概述

SpringDataElasticsearch（以后简称SDE）是Spring Data项目下的一个子模块。

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

Spring Data 的使命是给各种数据访问提供统一的编程接口，不管是关系型数据库（如MySQL），还是非关系数据库（如Redis），或者类似Elasticsearch这样的索引数据库。从而简化开发人员的代码，提高开发效率。

包含很多不同数据操作的模块：

Spring Data Elasticsearch的页面：https://projects.spring.io/spring-data-elasticsearch/

特征：

• 支持Spring的基于@Configuration的java配置方式，或者XML配置方式
• 提供了用于操作ES的便捷工具类**ElasticsearchTemplate**。包括实现文档到POJO之间的自动智能映射。
• 利用Spring的数据转换服务实现的功能丰富的对象映射
• 基于注解的元数据映射方式，而且可扩展以支持更多不同的数据格式
• 根据持久层接口自动生成对应实现方法，无需人工编写基本操作代码（类似mybatis，根据接口自动得到实现）。当然，也支持人工定制查询

配置

我们在pom文件中，引入SpringDataElasticsearch的启动器：

<?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.Eleganise</groupId><artifactId>SpringDataElasticSearch</artifactId><version>1.0-SNAPSHOT</version><!--引入spring父依赖--><parent><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-parent</artifactId><version>2.1.3.RELEASE</version></parent><!--导入业务依赖--><dependencies><!--引入SpringDataElasticsearch的启动器--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-elasticsearch</artifactId></dependency><!--spring-boot-starter-test--><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-test</artifactId></dependency><!--lombok--><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId></dependency></dependencies></project>

然后，只需要在resources下新建application.yml文件，引入elasticsearch的host和port即可：

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

需要注意的是，SpringDataElasticsearch底层使用TransportClient，并不采用Http协议通信，而是访问elasticsearch对外开放的tcp端口，我们之前集群配置中，设置的分别是：9301,9302,9303

索引数据CRUD

SpringDataElasticSearch的索引数据CRUD封装在一个叫做ElasticsearchRepository的接口：

我们需要自定义接口，继承ElasticsearchRespository：

package com.Eleganise.Demo.repository;import com.Eleganise.Demo.pojo.Goods;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;import java.util.List;//ElasticsearchRepository封装了简单的CRUD(根据id做简单的CRUD)
public interface GoodsRepository extends ElasticsearchRepository<Goods, Long> {//根据Title词条进行查询List<Goods> findByTitle(String title);//根据Title和Brand词条进行查询List<Goods> findByTitleAndBrand(String title, String brand);
}

SpringDataElasticSearch是通过实体类上的注解来配置索引库信息的

我们来创建Goods对象并在属性上添加一些注解：

package com.Eleganise.Demo.pojo;import lombok.AllArgsConstructor;
import lombok.Data;
import lombok.NoArgsConstructor;
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;/*** 一个goods对象,对应ES中的一个文档*/
@Data
@NoArgsConstructor
@AllArgsConstructor
@Document(indexName = "goods", type = "docs", shards = 1)
public class Goods {@Id//指定当前属性为doc的唯一指定idprivate Long id;//Text建立索引,分词@Field(type = FieldType.Text, analyzer = "ik_max_word")private String title; //标题//Keyword建立索引,不分词@Field(type = FieldType.Keyword)private String category;// 分类@Field(type = FieldType.Keyword)private String brand; // 品牌@Field(type = FieldType.Double)private Double price; // 价格@Field(type = FieldType.Keyword, index = false)private String images; // 图片地址}

几个用到的注解：

• @Document：声明索引库配置
  • indexName：索引库名称
  • type：类型名称，默认是“docs”
  • shards：分片数量，默认5
  • replicas：副本数量，默认1
• @Id：声明实体类的id
• @Field：声明字段属性
  • type：字段的数据类型
  • analyzer：指定分词器类型
  • index：是否创建索引

创建索引数据

创建索引有单个创建和批量创建之分，先来看单个创建

@Autowiredprivate GoodsRepository repository;/*** 创建索引,并添加文档*/@Testpublic void insertTest() {//创建商品Goods goods = new Goods(2l, " AI人脸解锁 莱茵护眼全面屏 4GB+64GB 耀夜黑 游戏智能老人手机", "手机", "华为", 5999.00, "http45487");//将商品存储到elasticsearch上repository.save(goods);}

查看索引库，发现索引库和mapping信息都已经创建了，

就是因为在Goods对象中，我们添加@Document 和@Field注解：

再来看批量创建：

@Test
public void addDocumentsTest(){// 准备文档数据：List<Goods> list = new ArrayList<>();list.add(new Goods(1L, "小米手机7", "手机", "小米", 3299.00, "/13123.jpg"));list.add(new Goods(2L, "坚果手机R1", "手机", "锤子", 3699.00, "/13123.jpg"));list.add(new Goods(3L, "华为META10", "手机", "华为", 4499.00, "/13123.jpg"));list.add(new Goods(4L, "小米Mix2S", "手机", "小米", 4299.00, "/13123.jpg"));list.add(new Goods(5L, "荣耀V10", "手机", "华为", 2799.00, "/13123.jpg"));// 添加索引数据repository.saveAll(list);
}

通过head-master插件查看：

查询索引数据

默认提供了根据id查询，查询所有两个功能：

根据id查询

    /*** 根据id查询*/@Testpublic void selectTest() {//Optiona能判断goods这个对象是否存在Optional<Goods> goods = repository.findById(1l);//获取到里面的对象Goods good = goods.get();//输出对象System.out.println(good);}

查询所有：

@Test
public void selectAllTest(){Iterable<Goods> list = repository.findAll();list.forEach(System.out::println);
}

更新文档：

    /*** 更新文档*/@Testpublic void updateTest() {//修改商品(当增加的对象id在数据库中已经存在的时候,那么新增操作就会进行覆盖,也就是更新)Goods goods = new Goods(1l, "iphone8 pro", "手机", "苹果", 8999.00, "http45487");//将商品存储到elasticsearch上repository.save(goods);}

删除文档

    /*** 删除文档*/@Testpublic void deleteTest() {repository.deleteById(1l);

方法命名查询

GoodsRepository提供的查询方法有限，但是它却提供了非常强大的自定义查询功能：

一般称为方法命名查询

查询方法以 findBy 开头，涉及条件查询时，条件的属性用条件关键字连接。

要注意的是：条件属性首字母需大写。框架在进行方法名解析时，会先把方法名多余的前缀截取掉，然后对剩下部分进行解析 。

只要遵循语法，我们可以任意定义方法声明：

package com.Eleganise.Demo.repository;import com.Eleganise.Demo.pojo.Goods;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;import java.util.List;//ElasticsearchRepository封装了简单的CRUD(根据id做简单额crud)
public interface GoodsRepository extends ElasticsearchRepository<Goods, Long> {//根据Title词条进行查询List<Goods> findByTitle(String query);//根据Title和Brand词条进行查询List<Goods> findByTitleAndBrand(String title, String brand);
}

无需写实现，SDE会自动帮我们实现该方法，我们只需要用即可：

/*** 方法命名查询*/@Testpublic void findByTitleTest() {List<Goods> list = repository.findByTitle("手机");for (Goods goods : list) {System.out.println(goods);}}/*** 方法命名查询*/@Testpublic void findByTitleAndBrandTest() {List<Goods> list = repository.findByTitleAndBrand("手机", "华为");for (Goods goods : list) {System.out.println(goods);}}

支持的一些语法示例：

Keyword	Sample	Elasticsearch Query String
And	findByNameAndPrice	{"bool" : {"must" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}
Or	findByNameOrPrice	{"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"price" : "?"}} ]}}
Is	findByName	{"bool" : {"must" : {"field" : {"name" : "?"}}}}
Not	findByNameNot	{"bool" : {"must_not" : {"field" : {"name" : "?"}}}}
Between	findByPriceBetween	{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
LessThanEqual	findByPriceLessThan	{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
GreaterThanEqual	findByPriceGreaterThan	{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}
Before	findByPriceBefore	{"bool" : {"must" : {"range" : {"price" : {"from" : null,"to" : ?,"include_lower" : true,"include_upper" : true}}}}}
After	findByPriceAfter	{"bool" : {"must" : {"range" : {"price" : {"from" : ?,"to" : null,"include_lower" : true,"include_upper" : true}}}}}
Like	findByNameLike	{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}
StartingWith	findByNameStartingWith	{"bool" : {"must" : {"field" : {"name" : {"query" : "?*","analyze_wildcard" : true}}}}}
EndingWith	findByNameEndingWith	{"bool" : {"must" : {"field" : {"name" : {"query" : "*?","analyze_wildcard" : true}}}}}
Contains/Containing	findByNameContaining	{"bool" : {"must" : {"field" : {"name" : {"query" : "**?**","analyze_wildcard" : true}}}}}
In	findByNameIn(Collection<String>names)	{"bool" : {"must" : {"bool" : {"should" : [ {"field" : {"name" : "?"}}, {"field" : {"name" : "?"}} ]}}}}
NotIn	findByNameNotIn(Collection<String>names)	{"bool" : {"must_not" : {"bool" : {"should" : {"field" : {"name" : "?"}}}}}}
Near	findByStoreNear	Not Supported Yet !
True	findByAvailableTrue	{"bool" : {"must" : {"field" : {"available" : true}}}}
False	findByAvailableFalse	{"bool" : {"must" : {"field" : {"available" : false}}}}
OrderBy	findByAvailableTrueOrderByNameDesc	{"sort" : [{ "name" : {"order" : "desc"} }],"bool" : {"must" : {"field" : {"available" : true}}}}

原生查询

如果觉得上述接口依然不符合你的需求，SDE也支持原生查询，这个时候还是使用ElasticsearchTemplate

而查询条件的构建是通过一个名为NativeSearchQueryBuilder的类来完成的，不过这个类的底层还是使用的原生API中的QueryBuilders、AggregationBuilders、HighlightBuilders等工具。

示例：

    /*** 原生查询器*/@Testpublic void nativeSearchQueryBuilder() {//原生查询构建器NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();//配置返回的字段(FetchSourceFilter两个参数,第一个是返回包含的内容,第二个是不包含的内容)queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{"id", "title", "price"}, null));//添加查询关键字,修改默认的or为andqueryBuilder.withQuery(QueryBuilders.matchQuery("title", "手机").operator(Operator.OR));//添加分页信息(page:是第几页  size:每页显示多少条)queryBuilder.withPageable(PageRequest.of(0, 10));//设置高亮字段queryBuilder.withHighlightFields(new HighlightBuilder.Field("title"));//自定义高亮标签queryBuilder.withHighlightBuilder(new HighlightBuilder().preTags("<123546>").postTags("</456>"));//设置聚合的名字String brandAggsName = "brandAggs";//往queryBuilder中设置聚合名字和聚合的字段queryBuilder.addAggregation(AggregationBuilders.terms(brandAggsName).field("brand"));/*** 发送到es的服务端,并获取结果* queryForPage方法需要两个对象* 1.SearchQuery对象,用NativeSearchQueryBuilder对象build一下得到* 2.clazz对象,用来表明查询哪个索引,因为索引类上有注解@Document(indexName = "goods", type = "docs", shards = 1),可以标明索引和类型* 3.自定义内部类*/AggregatedPage<Goods> aggregatedPage = template.queryForPage(queryBuilder.build(), Goods.class, new MySearchMapper());//返回总页数int totalPages = aggregatedPage.getTotalPages();//输出总页数System.out.println("总页数:" + totalPages);//返回总条数long totalElements = aggregatedPage.getTotalElements();//输出总条数System.out.println("总条数:" + totalElements);//得到返回的最终结果List<Goods> goodsList = aggregatedPage.getContent();//输出结果列表System.out.println(goodsList);//获取聚合的结果Aggregations aggregations = aggregatedPage.getAggregations();/*** 根据聚合的名字,获取真的存放聚合结果的内容* 因为aggregations.get()方法返回的结果是Aggregation类型的对象,这个对象并不能得到我们想要的bucket桶* 所以我们用StringTerms来接收对象,如果结果是long类型的,那么就用LongTerms来接收,*/StringTerms aggregation = aggregations.get(brandAggsName);//获取聚合结果的桶List<StringTerms.Bucket> buckets = aggregation.getBuckets();//循环遍历桶对象for (StringTerms.Bucket bucket : buckets) {//用字符串的形式得到的对象String keyAsString = bucket.getKeyAsString();//输出对象System.out.println("聚合的内容:" + keyAsString);}}

上述查询不支持高亮结果，悲剧。

自定义结果处理器

要支持高亮，必须自定义结果处理器来实现，结果处理器是一个接口：

可以看到，处理器中的方法接受3个参数：

• SearchResponse：搜索的Response，原生查询中就见到过
• Class<T> clazz：结果的实体类的字节码，本例中的是Goods.class
• Pageable：分页参数，就是我们定义的PageRequest

返回值一个：AggregatedPage<T>，就是带聚合的分页结果

我们创建一个内部类,实现下面的方法：

/*** 自定义结果处理* 这里我们主要做高亮的处理*/
class MySearchMapper implements SearchResultMapper {@Overridepublic <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {//创建一个ObjectMapper用来把获取到的字符串转换成bean对象ObjectMapper objectMapper = new ObjectMapper();//获取结果的总条数long totalHits = searchResponse.getHits().getTotalHits();/*** 游标id* 用于大数据的查询,大量数据返回的时候,这个属性的作用是记录上一页最后一条数据的id*/String scrollId = searchResponse.getScrollId();//最大分数float maxScore = searchResponse.getHits().getMaxScore();//聚合的内容Aggregations aggregations = searchResponse.getAggregations();//创建一个集合List<T> content = new ArrayList<>();//命中所有内容SearchHits hits = searchResponse.getHits();//遍历hitsfor (SearchHit hit : hits) {//获取文档的json数据String sourceAsString = hit.getSourceAsString();try {/*** 文档的bean对象(goods对象)* 把json数据转成一个bean数据,也就是传递过来的goods对象*/T t = objectMapper.readValue(sourceAsString, aClass);//获取字段的高亮内容,替换原始内容的字段值//highlightFieldMap   key - 高亮的字段名字  value - 高亮的内容Map<String, HighlightField> highlightFields = hit.getHighlightFields();//遍历高亮的集合for (String fieldName : highlightFields.keySet()) {/*** 获取高亮段* 根据键获取map集合的值,也就是高亮的内容,然后用getFragments()方法把设定的标签进行拼接*/Text[] texts = highlightFields.get(fieldName).getFragments();/*** 获取高亮内容* 用工具类把数组中高亮段拼接到一起*/String hightValue = StringUtils.join(texts);/*** 替换原始内容的字段值* 用工具类替换 t 中的fieldName对应的值,替换的值为新的hightValue*/BeanUtils.setProperty(t, fieldName, hightValue);}//把处理后的对象T放入集合content.add(t);} catch (IOException | IllegalAccessException | InvocationTargetException e) {e.printStackTrace();}}return new AggregatedPageImpl<>(content, pageable, totalHits, aggregations, scrollId, maxScore);}
}

总代码

package com.Eleganise.Demo;import com.Eleganise.Demo.pojo.Goods;
import com.Eleganise.Demo.repository.GoodsRepository;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.apache.commons.beanutils.BeanUtils;
import org.apache.commons.lang3.StringUtils;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.common.text.Text;
import org.elasticsearch.index.query.Operator;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.Aggregations;
import org.elasticsearch.search.aggregations.bucket.terms.StringTerms;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightBuilder;
import org.elasticsearch.search.fetch.subphase.highlight.HighlightField;
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.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.elasticsearch.core.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.SearchResultMapper;
import org.springframework.data.elasticsearch.core.aggregation.AggregatedPage;
import org.springframework.data.elasticsearch.core.aggregation.impl.AggregatedPageImpl;
import org.springframework.data.elasticsearch.core.query.FetchSourceFilter;
import org.springframework.data.elasticsearch.core.query.NativeSearchQueryBuilder;
import org.springframework.test.context.junit4.SpringRunner;import java.io.IOException;
import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Optional;@RunWith(SpringRunner.class)
@SpringBootTest
public class MyTest {@Autowiredprivate GoodsRepository repository;/*** spring-boot-starter-data-elasticsearch注入的模板类*/@Autowiredprivate ElasticsearchTemplate template;/*** 创建索引,并添加文档*/@Testpublic void insertTest() {//创建商品Goods goods = new Goods(2l, " AI人脸解锁 莱茵护眼全面屏 4GB+64GB 耀夜黑 游戏智能老人手机", "手机", "华为", 5999.00, "http45487");//将商品存储到elasticsearch上repository.save(goods);}/*** 批量添加文档*/@Testpublic void addDocuments() {// 准备文档数据：List<Goods> list = new ArrayList<>();list.add(new Goods(1L, "小米手机7", "手机", "小米", 3299.00, "/13123.jpg"));list.add(new Goods(2L, "坚果手机R1", "手机", "锤子", 3699.00, "/13123.jpg"));list.add(new Goods(3L, "华为META10", "手机", "华为", 4499.00, "/13123.jpg"));list.add(new Goods(4L, "小米Mix2S", "手机", "小米", 4299.00, "/13123.jpg"));list.add(new Goods(5L, "荣耀V10", "手机", "华为", 2799.00, "/13123.jpg"));// 添加索引数据repository.saveAll(list);}/*** 查询词条*/@Testpublic void selectTest() {//Optiona能判断goods这个对象是否存在Optional<Goods> goods = repository.findById(1l);//获取到里面的对象Goods good = goods.get();//输出对象System.out.println(good);}/*** 查询所有*/@Testpublic void selectAllTest() {Iterable<Goods> list = repository.findAll();list.forEach(System.out::println);}/*** 更新文档*/@Testpublic void updateTest() {//修改商品(当增加的对象id在数据库中已经存在的时候,那么新增操作就会进行覆盖,也就是更新)Goods goods = new Goods(1l, "iphone8 pro", "手机", "苹果", 8999.00, "http45487");//将商品存储到elasticsearch上repository.save(goods);}/*** 删除文档*/@Testpublic void deleteTest() {repository.deleteById(1l);}/*** 方法命名查询*/@Testpublic void findByTitleTest() {List<Goods> list = repository.findByTitle("手机");for (Goods goods : list) {System.out.println(goods);}}/*** 方法命名查询*/@Testpublic void findByTitleAndBrandTest() {List<Goods> list = repository.findByTitleAndBrand("手机", "华为");for (Goods goods : list) {System.out.println(goods);}}/*** 原生查询器*/@Testpublic void nativeSearchQueryBuilder() {//原生查询构建器NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();//配置返回的字段(FetchSourceFilter两个参数,第一个是返回包含的内容,第二个是不包含的内容)queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{"id", "title", "price"}, null));//添加查询关键字,修改默认的or为andqueryBuilder.withQuery(QueryBuilders.matchQuery("title", "手机").operator(Operator.OR));//添加分页信息(page:是第几页  size:每页显示多少条)queryBuilder.withPageable(PageRequest.of(0, 10));//设置高亮字段queryBuilder.withHighlightFields(new HighlightBuilder.Field("title"));//自定义高亮标签queryBuilder.withHighlightBuilder(new HighlightBuilder().preTags("<123546>").postTags("</456>"));//设置聚合的名字String brandAggsName = "brandAggs";//往queryBuilder中设置聚合名字和聚合的字段queryBuilder.addAggregation(AggregationBuilders.terms(brandAggsName).field("brand"));/*** 发送到es的服务端,并获取结果* queryForPage方法需要两个对象* 1.SearchQuery对象,用NativeSearchQueryBuilder对象build一下得到* 2.clazz对象,用来表明查询哪个索引,因为索引类上有注解@Document(indexName = "goods", type = "docs", shards = 1),可以标明索引和类型* 3.自定义内部类*/AggregatedPage<Goods> aggregatedPage = template.queryForPage(queryBuilder.build(), Goods.class, new MySearchMapper());//返回总页数int totalPages = aggregatedPage.getTotalPages();//输出总页数System.out.println("总页数:" + totalPages);//返回总条数long totalElements = aggregatedPage.getTotalElements();//输出总条数System.out.println("总条数:" + totalElements);//得到返回的最终结果List<Goods> goodsList = aggregatedPage.getContent();//输出结果列表System.out.println(goodsList);//获取聚合的结果Aggregations aggregations = aggregatedPage.getAggregations();/*** 根据聚合的名字,获取真的存放聚合结果的内容* 因为aggregations.get()方法返回的结果是Aggregation类型的对象,这个对象并不能得到我们想要的bucket桶* 所以我们用StringTerms来接收对象,如果结果是long类型的,那么就用LongTerms来接收,*/StringTerms aggregation = aggregations.get(brandAggsName);//获取聚合结果的桶List<StringTerms.Bucket> buckets = aggregation.getBuckets();//循环遍历桶对象for (StringTerms.Bucket bucket : buckets) {//用字符串的形式得到的对象String keyAsString = bucket.getKeyAsString();//输出对象System.out.println("聚合的内容:" + keyAsString);}}}/*** 自定义结果处理* 这里我们主要做高亮的处理*/
class MySearchMapper implements SearchResultMapper {@Overridepublic <T> AggregatedPage<T> mapResults(SearchResponse searchResponse, Class<T> aClass, Pageable pageable) {//创建一个ObjectMapper用来把获取到的字符串转换成bean对象ObjectMapper objectMapper = new ObjectMapper();//获取结果的总条数long totalHits = searchResponse.getHits().getTotalHits();/*** 游标id* 用于大数据的查询,大量数据返回的时候,这个属性的作用是记录上一页最后一条数据的id*/String scrollId = searchResponse.getScrollId();//最大分数float maxScore = searchResponse.getHits().getMaxScore();//聚合的内容Aggregations aggregations = searchResponse.getAggregations();//创建一个集合List<T> content = new ArrayList<>();//命中所有内容SearchHits hits = searchResponse.getHits();//遍历hitsfor (SearchHit hit : hits) {//获取文档的json数据String sourceAsString = hit.getSourceAsString();try {/*** 文档的bean对象(goods对象)* 把json数据转成一个bean数据,也就是传递过来的goods对象*/T t = objectMapper.readValue(sourceAsString, aClass);//获取字段的高亮内容,替换原始内容的字段值//highlightFieldMap   key - 高亮的字段名字  value - 高亮的内容Map<String, HighlightField> highlightFields = hit.getHighlightFields();//遍历高亮的集合for (String fieldName : highlightFields.keySet()) {/*** 获取高亮段* 根据键获取map集合的值,也就是高亮的内容,然后用getFragments()方法把设定的标签进行拼接*/Text[] texts = highlightFields.get(fieldName).getFragments();/*** 获取高亮内容* 用工具类把数组中高亮段拼接到一起*/String hightValue = StringUtils.join(texts);/*** 替换原始内容的字段值* 用工具类替换 t 中的fieldName对应的值,替换的值为新的hightValue*/BeanUtils.setProperty(t, fieldName, hightValue);}//把处理后的对象T放入集合content.add(t);} catch (IOException | IllegalAccessException | InvocationTargetException e) {e.printStackTrace();}}return new AggregatedPageImpl<>(content, pageable, totalHits, aggregations, scrollId, maxScore);}
}