A081_Lucene_ElasticSearch
目录
-
-
- 1.内容介绍
- 2.认识全文检索
-
- 2.1.什么是全文检索
- 2.2.全文检索的特点
- 2.3.常见的全文检索方案
- 3.Lucene介绍
-
- 3.1.什么是Lucene
- 3.2.Lucene实现全文检索架构
-
- 3.2.1.索引创建
- 3.2.2.索引搜索
- 4.Lucene-Helloworld程序
-
- 4.1.创建索引
- 4.2.搜索索引
- 4.3.总结
- 5.认识ElasticSearch
-
- 5.1.为什么要使用ElasticSearch
- 5.2.ElasticSearch（简称ES）
- 5.3.ES的使用者及类似框架
- 5.4.小结
- 6.ES安装及使用说明
-
- 6.1.包含的内容
- 6.2.安装ES
- 6.3.ES交互方式客户端
- 6.4.扩展：Restful认识
- 6.4.辅助管理工具Kibana5
- 7.ES相关概念理解
-
- 7.1.Index：索引库
- 7.2.Type：类型
- 7.3.Document&field
- 8.ES文档操作
-
- 8.1.什么是ES中的文档
- 8.2.文档的增删改-重点掌握
- 8.3.文档的简单查询
-
- 8.3.1.通过文档ID获取
- 8.3.2.批量获取
- 8.3.3.空搜索
- 8.3.4.分页搜索
- 8.3.5 查询字符串搜索
- 8.4.小结
- 9.ES查询
-
- 9.1.DSL查询
-
- 1.什么是DSL
- 2.DSL查询
- 3.DSL过滤
- 4.使用DSL查询与过滤
- 9.2.高亮查询
- 9.3.聚合查询
-
- 1.Metrics Aggregations，指标聚合。
- 2.Value Count Aggregation，数量统计
- 3.distinct 去重聚合
- 4.统计聚合
- 5.拓展的统计聚合
- 6.Terms Aggregation 分组并统计数量
- 7.Top Hits 最高匹配
- 8.百分比排名聚合
- 9.4.小结
- 10.分词与映射
-
- 10.1.为什么要使用分词与映射
- 10.2.IK分词器
- 10.3.文档映射Mapper
-
- 1.ES字段类型
- 2.默认映射--掌握
- 3.简单类型映射
- 4.对象及数组类型映射--了解
- 6.全局映射
- 7.最佳实践
- 11.Java操作ES
-
- 11.1.集成ES
-
- 1.导入依赖
- 2.连接ES获取Client对象
- 11.2.crud实现
-
- 1.创建文档索引
- 2.获取文档
- 3.更新文档
- 4.删除文档
- 5.批量操作
- 6.搜索
- 12.SpringBoot操作ES
-
- 12.1.SpringBoot集成ES
-
- 1.导入依赖
- 2.配置ES
- 3.创建ES的文档对象
- 4.初始化索引库和文档映射
- 5.定义Repository
- 12.2.CRUD实现
-
- 1.添加数据
- 2.修改数据
- 3.删除数据
- 4.获取数据
- 5.高级查询
- 13.高亮
-
- 13.1.创建结果处理器
- 13.2.高亮查询
- 14.聚合查询
-
- 14.1.修改结果映射器
- 14.2.聚合查询
- 15.总结
-
- 1.重点
- 2.作业
-
1.内容介绍
1.认识全文检索
2.Lucene入门(掌握)
3.认识 ElasticSearch
4.ElasticSearch基本操作(掌握)
5.Java操作ElasticSearch(掌握)
2.认识全文检索
2.1.什么是全文检索
对非结构化数据的搜索就叫全文检索，狭义的理解主要针对文本数据的搜索。
结构化数据：
业界指关系模型数据，即以关系数据库表形式管理的数据
半结构数据：
非关系模型的、有基本固定结构模式的数据，例如日志文件、XML文档、JSON文档、Email等。
非结构化数据：
没有固定模式的数据，如WORD、PDF、PPT、EXL，各种格式的图片、视频等。
非结构化数据是数据结构不规则或不完整，没有预定义的数据模型，不方便用数据库二维逻辑表来表现的数据。包括所有格式的办公文档、文本、图片、XML, HTML、各类报表、图像和音频/视频信息等等
理解：可以理解为全文检索就是把没有结构化的数据变成有结构的数据，然后进行搜索，因为有结构化的数据通常情况下可以按照某种算法进行搜索。
2.2.全文检索的特点
相关度最高的排在最前面，官网中相关的网页排在最前面； java
关键词的高亮。
只处理文本,不处理语义。 以单词方式进行搜索
比如在输入框中输入“中国的首都在哪里”，搜索引擎不会以对话的形式告诉你“在北京”，而仅仅是列出包含了搜索关键字的网页。
2.3.常见的全文检索方案
全文搜索工具包-Lucene（核心）
全文搜索服务器 ，Elastic Search(ES) / Solr等封装了lucene并扩展
3.Lucene介绍
3.1.什么是Lucene
Lucene是apache下的一个开源的全文检索引擎工具包(一堆jar包)。它为软件开发人员提供一个简单易用的工具包（类库），以方便的在小型目标系统中实现全文检索的功能。
Lucene适用于中小型项目 ，ES适用于中大型项目（它底层是基于lucene实现的）
3.2.Lucene实现全文检索架构
任何技术都有一些核心，Lucene也有核心，而它的核心分为：索引创建，索引搜索。接下来我们就一一的来看。
3.2.1.索引创建
将现实世界中所有的结构化和非结构化数据提取信息，创建索引的过程。那么索引里面究竟存的什么，以及如何创建索引呢？在这通过下面的例子来解答这个问题。
首先构造三个不同的句子，有长有短：
在①处分别为3个句子加上编号，然后进行分词，把每一个单词分解出来与编号对应放在②处；在搜索的过程中，对于搜索的过程中大写和小写指的都是同一个单词，在这就没有区分的必要，按规则统一变为小写放在③处；要加快搜索速度，就必须保证这些单词的排列时有一定规则，这里按照字母顺序排列后放在④处；最后再简化索引，合并相同的单词，就得到如下结果：
通常在数据库中我们都是根据文档找到内容，而这里是通过词，能够快速找到包含他的文档，这就是文档倒排链表。
以上就是lucene索引结构中最核心的部分。我们注意到关键字是按字符顺序排列的（lucene没有使用B树结构），因此lucene可以用二元搜索算法快速定位关键词。
3.2.2.索引搜索
就是得到用户的查询请求，搜索创建的索引，然后返回结果的过程。
比如我们要搜索java world两个关键词，符合java的有1,2两个文档，符合world的有1,3两个文档，在搜索引擎中直接这样排列两个词他们之间是OR的关系，出现其中一个都可以被找到，所以这里3个都会出来。全文检索中是有相关性排序的，那么结果在是怎么排列的呢？hello java world中包含两个关键字排在第一，另两个都包含一个关键字，得到结果，hello lucene world排在第二，java在最长的句子中占的权重最低排在结果集的第三。从这里可以看出相关度排序还是有一定规则的。
1.Lucene入门
4.Lucene-Helloworld程序
Lucene的索引库和数据库一样，都提供相应的API来便捷操作。
Lucene中的索引维护使用IndexWriter，由这个类提供添删改相关的操作；索引的搜索则是使用IndexSearcher进行索引的搜索。
HelloWorld代码如下,导入三个jar包：lucene-analyzers-common-5.5.0.jar，lucene-core-5.5.0.jar，lucene-queryparser-5.5.0.jar
<dependency>
<groupId>org.apache.lucenegroupId>
<artifactId>lucene-coreartifactId>
<version>5.5.0version>
dependency>
<dependency>
<groupId>org.apache.lucenegroupId>
<artifactId>lucene-analyzers-commonartifactId>
<version>5.5.0version>
dependency>
<dependency>
<groupId>org.apache.lucenegroupId>
<artifactId>lucene-queryparserartifactId>
<version>5.5.0version>
dependency>
4.1.创建索引
步骤：
1、把文本内容转换为Document对象
2、准备IndexWriter（索引写入器）
3、通过IndexWriter，把Document添加到缓冲区并提交
//创建索引的数据 现在写死，以后根据实际应用场景
String doc1 = "hello world";
String doc2 = "hello java world";
String doc3 = "hello lucene world";
private String path ="F:/eclipse/workspace/lucene/index/hello";
@Test
public void testCreate() {
try {
//2、准备IndexWriter（索引写入器）
//索引库的位置 FS fileSystem
Directory d = FSDirectory.open(Paths.get(path ));
//分词器 -- 把文档进行分词
Analyzer analyzer = new SimpleAnalyzer();
//索引写入器的配置对象
IndexWriterConfig conf = new IndexWriterConfig(analyzer);
IndexWriter indexWriter = new IndexWriter(d, conf);
System.out.println(indexWriter);
//1、 把文本内容转换为Document对象
//把文本转换为document对象
Document document1 = new Document();
//标题字段
document1.add(new TextField("title", "doc1", Store.YES));
document1.add(new TextField("content", doc1, Store.YES));
//添加document到缓冲区
indexWriter.addDocument(document1);
Document document2 = new Document();
//标题字段
document2.add(new TextField("title", "doc2", Store.YES));
document2.add(new TextField("content", doc2, Store.YES));
//添加document到缓冲区
indexWriter.addDocument(document2);
Document document3 = new Document();
//标题字段
document3.add(new TextField("title", "doc3", Store.YES));
document3.add(new TextField("content", doc3, Store.YES));
//3 、通过IndexWriter，把Document添加到缓冲区并提交
//添加document到缓冲区
indexWriter.addDocument(document3);
indexWriter.commit();
indexWriter.close();
} catch (Exception e) {
e.printStackTrace();
}
}
4.2.搜索索引
1 封装查询提交为查询对象
2 准备IndexSearcher
3 使用IndexSearcher传入查询对象做查询-----查询出来只是文档编号DocID
4 通过IndexSearcher传入DocID获取文档
5 把文档转换为前台需要的对象
@Test
public void testSearch() {
String keyWord = "lucene";
try {
// * 1 封装查询提交为查询对象
//通过查询解析器解析一个字符串为查询对象
String f = "content"; //查询的默认字段名,
Analyzer a = new SimpleAnalyzer();//查询关键字要分词，所有需要分词器
QueryParser parser = new QueryParser(f, a);
Query query = parser.parse("content:"+keyWord);
// * 2 准备IndexSearcher
Directory d = FSDirectory.open(Paths.get(path ));
IndexReader r = DirectoryReader.open(d);
IndexSearcher searcher = new IndexSearcher(r);
// * 3 使用IndexSearcher传入查询对象做查询-----查询出来只是文档编号DocID
TopDocs topDocs = searcher.search(query, 1000);//查询ton条记录 前多少条记录
System.out.println("总命中数："+topDocs.totalHits);
ScoreDoc[] scoreDocs = topDocs.scoreDocs;//命中的所有的文档的封装（docId）
// * 4 通过IndexSearcher传入DocID获取文档
for (ScoreDoc scoreDoc : scoreDocs) {
int docId = scoreDoc.doc;
Document document = searcher.doc(docId);
// * 5 把文档转换为前台需要的对象 Docment----> Article
System.out.println("=======================================");
System.out.println("title:"+document.get("title")
+",content:"+document.get("content"));
}
} catch (Exception e) {
e.printStackTrace();
}
}
4.3.总结
1.哪些字段需要索引以及分词？
2.哪些字段需要索引但是不需要分词？
要进行搜索的字段就要创建索引(倒排索引文档)
不参与搜索的字段不创建索引
要进行关键字搜索的(模糊)字段就要索引且要分词 - intro like “%xx%”
需要进行等值查询的要索引但是不分词 - name = “oo”
3.哪些数据要放到数据区的？
1.列表需要展示的数据
2.查询条件需要用到的数据（要创建索引库，不一定要放到数据去）
5.认识ElasticSearch
5.1.为什么要使用ElasticSearch
虽然全文搜索领域，Lucene可以被认为是迄今为止最先进、性能最好的、功能最全的搜索引擎库。但是，Lucene只是一个库。想要使用它，你必须使用Java来作为开发语言并将其直接集成到你的应用中，更糟糕的是，Lucene的配置及使用非常复杂，你需要深入了解检索的相关知识来理解它是如何工作的。
实际项目中，我们建立一个网站或应用程序，并要添加搜索功能，令我们受打击的是：搜索工作是很难的。我们希望我们的搜索解决方案要快，我们希望有一个零配置和一个完全免费的搜索模式，我们希望能够简单地使用JSON/XML通过HTTP的索引数据，我们希望我们的搜索服务器始终可用，我们希望能够从一台开始并在需要扩容时方便地扩展到数百，我们要实时搜索，我们要简单的多租户，我们希望建立一个云的解决方案。
5.2.ElasticSearch（简称ES）
ES即为了解决原生Lucene使用的不足，优化Lucene的调用方式，并实现了高可用的分布式集群的搜索方案，其第一个版本于2010年2月出现在GitHub上并迅速成为最受欢迎的项目之一。
首先，ES的索引库管理支持依然是基于Apache Lucene™的开源搜索引擎。
ES也使用Java开发并使用Lucene作为其核心来实现所有索引和搜索的功能，但是它的目的是通过简单的 RESTful API来隐藏Lucene的复杂性，从而让全文搜索变得简单。
不过，ES的核心不在于Lucene，其特点更多的体现为：
- 分布式的实时文件存储，每个字段都被索引并可被搜索
- 分布式的实时分析搜索引擎
- 可以扩展到上百台服务器，处理PB级结构化或非结构化数据：KB-MB-GB-TB-PB
- 高度集成化的服务，你的应用可以通过简单的 RESTful API、各种语言的客户端甚至命令行与之交互。
- 上手Elasticsearch非常容易。它提供了许多合理的缺省值，并对初学者隐藏了复杂的搜索引擎理论。它拥有开瓶即饮的效果（安装即可使用），只需很少的学习既可在生产环境中使用。
5.3.ES的使用者及类似框架
典型使用案例
- Github(美国)使用Elasticsearch搜索20TB的数据，包括13亿的文件和1300亿行的代码.
- Foursquare实时搜索5千万地点信息？Foursquare每天都用Elasticsearch做这样的事.
- 德国SoundCloud使用Elasticsearch来为1.8亿用户提供即时精准的音乐搜索服务.
- Mozilla公司以火狐著名，它目前使用 WarOnOrange 这个项目来进行单元或功能测试，测试的结果以 json的方式索引到elasticsearch中，开发人员可以非常方便的查找 bug.
- Sony公司使用elasticsearch 作为信息搜索引擎.
类似框架
- Solr（重量级对手）
Apache Lucene项目的开源企业搜索平台。其主要功能包括全文检索、命中标示、分面搜索、动态聚类、数据库集成，以及富文本（如Word、PDF）的处理。Solr是高度可扩展的，并提供了分布式搜索和索引复制。Solr是最流行的企业级搜索引擎，Solr4 还增加了NoSQL支持。Solr和ES比较：
Solr 利用 Zookeeper(注册中心) 进行分布式管理，支持更多格式的数据（HTML/PDF/CSV），官方提供的功能更多在传统的搜索应用中表现好于 ES，但实时搜索效率低。
ES自身带有分布式协调管理功能，但仅支持json文件格式，本身更注重于核心功能，高级功能多有第三方插件提供，在处理实时搜索应用时效率明显高于 Solr 。 - Katta
基于 Lucene 的，支持分布式，可扩展，具有容错功能，准实时的搜索方案。
优点：开箱即用，可以与 Hadoop (大数据)配合实现分布式。具备扩展和容错机制。
缺点：只是搜索方案，建索引部分还是需要自己实现。在搜索功能上，只实现了最基本的需求。成功案例较少，项目的成熟度稍微差一些。 - HadoopContrib --大数据相关的东西 (大数据工程师)
Map/Reduce 模式(云计算)的，分布式建索引方案，可以跟 Katta 配合使用。
优点：分布式建索引，具备可扩展性。
缺点：只是建索引方案，不包括搜索实现。工作在批处理模式，对实时搜索的支持不佳。
5.4.小结
ElasticSearch简化了全文检索lucene的使用，同时增加了分布式的特性，使得构建大规模分布式全文检索变得非常容易。
6.ES安装及使用说明
6.1.包含的内容
ES的安装比较简单，只需要官方下载ES的运行包，然后启动ES服务即可。
ES的使用主要是通过能够发起HTTP请求的终端来接入，比如Poster插件、CURL、kibana5等。
6.2.安装ES
ES服务只依赖于JDK，推荐使用JDK1.7+。
① 下载ES安装包
官方下载地址：https://www.elastic.co/downloads/elasticsearch
本课程以在window环境下，ES 5.2.2版本为例，下载对应的ZIP文件
② 运行ES
bin/elasticsearch.bat
③ 验证
访问：http://localhost:9200/
看到上图信息，恭喜你，你的ES集群已经启动并且正常运行.
6.3.ES交互方式客户端
① 基于RESTful API
ES和所有客户端的交互都是使用JSON格式的数据.
其他所有程序语言都可以使用RESTful API，通过9200端口的与ES进行通信，在开发测试阶段，你可以使用你喜欢的WEB客户端， curl命令以及火狐的POSTER插件方式和ES通信。
Curl命令方式：
默认windows下不支持curl命令，在资料中有curl的工具及简单使用说明。
火狐的POSTER插件界面：
类似于Firebug，在火狐的“扩展”中搜索“POSTER”，并安装改扩展工具。
使用POSTER模拟请求的效果
② Java API
ES为Java用户提供了两种内置客户端：
节点客户端(node client)：节点客户端以无数据节点(none data node)身份加入集群，换言之，它自己不存储任何数据，但是它知道数据在集群中的具体位置，并且能够直接转发请求到对应的节点上。
传输客户端(Transport client)：这个更轻量的传输客户端能够发送请求到远程集群。它自己不加入集群，只是简单转发请求给集群中的节点。
两个Java客户端都通过9300端口与集群交互，使用ES传输协议(ES Transport Protocol)。集群中的节点
之间也通过9300端口进行通信。如果此端口未开放，你的节点将不能组成集群。
注意：Java客户端所在的ES版本必须与集群中其他节点一致，否则，它们可能互相无法识别。
6.4.扩展：Restful认识
Restful是一种面向资源的架构风格，可以简单理解为：使用URL名词定位资源，用HTTP动词（GET,POST,DELETE,PUT）描述操作。
使用Restful的好处：
透明性，暴露资源存在。充分利用 HTTP 协议本身语义。
无状态，这点非常重要。在调用一个接口（访问、操作资源）的时候，可以不用考虑上下文，不用考虑当前状态，极大的降低了复杂度。
HTTP 本身提供了丰富的内容协商手段，无论是缓存，还是资源修改的乐观并发控制，都可以以业务无关的中间件来实现。
Restful的典型特征：
Server提供的RESTful API中，URL中只使用名词来指定资源。
“资源”是REST架构或者说整个网络处理的核心。比如：
GET http://api.itsource.cn/emp/323: 获取323号员工的基本资料;
GET http://api.itsource.cn/emps: 获取源码时代所有员工资料列表;
REST 是面向资源的，这个概念非常重要，而资源是通过 URI 进行暴露
URI 的设计只要负责把资源通过合理方式暴露出来就可以了。对资源的操作与它无关，所以REST 通过 URI 暴露资源时，会强调不要在 URI 中出现动词。
比如：左边是错误的设计，而右边是正确的
GET /rest/api/getDogs -> GET /rest/api/dogs 获取所有小狗狗
GET /rest/api/getDogById?id=1 -> GET /rest/api/dog/1 获取所有小狗狗
GET /rest/api/addDogs -> POST /rest/api/dogs 添加一个小狗狗
POST /rest/api/editDogs/12 -> PUT /rest/api/dogs/12 修改一个小狗狗
POST /rest/api/deleteDogs/12 ->DELETE /rest/api/dogs/12 删除一个小狗
左边的这种设计，很明显不符合REST风格，URI 只负责准确无误的暴露资源，而 getDogs/addDogs…已经包含了对资源的操作，这是不对的。相反右边却满足了，它的操作是使用标准的HTTP动词来体现。
③ 用HTTP协议里的动词来实现资源的添加，修改，删除等操作。
即通过HTTP动词来实现资源的状态扭转：
GET 用来获取资源，
POST 用来新建资源（也可以用于更新资源），
PUT 用来更新资源，
DELETE 用来删除资源。
比如：
GET http://api.itsource.cn/emp/323
POST http://api.itsource.cn/emp/232: 修改一个员工
PUT http://api.itsource.cn/emp: 添加员工资料
DELETE http://api.itsource.cn/emp/323: 删除323号员工
6.4.辅助管理工具Kibana5
① Kibana5.2.2下载地址：https://www.elastic.co/downloads/kibana
② 解压并编辑config/kibana.yml，设置elasticsearch.url的值为已启动的ES
③ 启动Kibana5 : bin\kibana.bat
④ 默认访问地址：http://localhost:5601
Discover：可视化查询分析器
Visualize：统计分析图表
Dashboard：自定义主面板（添加图表）
Timelion：Timelion是一个kibana时间序列展示组件（暂时不用）
Dev Tools ：Console（同CURL/POSTER，操作ES代码工具，代码提示，很方便）
Management：管理索引库(index)、已保存的搜索和可视化结果(save objects)、设置 kibana 服务器属性。
7.ES相关概念理解
7.1.Index：索引库
包含一堆有相似结构的文档数据，比如可以有一个客户索引，商品分类索引，订单索引，索引有一个名称。一个index包含很多document，一个index就代表了一类类似的或者相同的document。比如说建立一个product index，商品索引，里面可能就存放了所有的商品数据，所有的商品document。
7.2.Type：类型
每个索引里都可以有一个或多个type，type是index中的一个逻辑数据分类，一个type下的document，都有相同的field，比如博客系统，有一个索引，可以定义用户数据type，博客数据type，评论数据type。
7.3.Document&field
文档，es中的最小数据单元，一个document可以是一条客户数据，一条商品分类数据，一条订单数据，通常用JSON数据结构表示，每个index下的type中，都可以去存储多个document。一个document里面有多个field，每个field就是一个数据字段
8.ES文档操作
8.1.什么是ES中的文档
document --存放数据
在ES里面 通过index索引库 type 类型(表) 行(｛id:name:｝) 列 id /name
ES是面向文档(document oriented)的，这意味着它可以存储整个对象或文档(document)。然而它不仅仅是存储，还会索引(index)每个文档的内容使之可以被搜索。在ES中，你可以对文档（而非成行成列的数据）进行索引、搜索、排序、过滤。
ES使用Javascript对象符号(JavaScript Object Notation)，也就是JSON，作为文档序列化格式。JSON现在已经被大多语言所支持，而且已经成为NoSQL领域的标准格式。
ES存储的一个员工文档的格式示例：
{
"email": "[email protected]",
"name": "老郑",
"info": {
"addr": "四川省成都市",
"age": 30,
"interests": [ "美食", "美女" ]
},
"join_date": "2016-06-01"
}
尽管原始的 employee对象很复杂，但它的结构和对象的含义已经被完整的体现在JSON中了，在ES中将对象转化为JSON并做索引要比在表结构中做相同的事情简单的多。
一个文档不只有数据。它还包含元数据(metadata)—关于文档的信息。三个必须的元数据节点是：
_index：索引库，类似于关系型数据库里的“数据库”—它是我们存储和索引关联数据的地方。
_type：在应用中，我们使用对象表示一些“事物”，例如一个用户、一篇博客、一个评论，或者一封邮件。可以是大写或小写，不能包含下划线或逗号。我们将使用 employee 做为类型名。
_id:与 _index 和 _type 组合时，就可以在ELasticsearch中唯一标识一个文档。当创建一个文档，你可以自定义 _id ，也可以让Elasticsearch帮你自动生成。
另外还包括：_uid文档唯一标识(_type#_id)
_source：文档原始数据
_all：所有字段的连接字符串
8.2.文档的增删改-重点掌握
我们以员工对象为例，我们首先要做的是存储员工数据，每个文档代表一个员工。在ES中存储数据的行为就叫做索引(indexing)，文档归属于一种类型(type),而这些类型存在于索引(index)中，我们可以简单的对比传统数据库和ES的对应关系：
关系数据库（MYSQL）-> 数据库DB -> 表TABLE -> 行ROW -> 列Column
Elasticsearch -> 索引库Indices -> 类型Types -> 文档Documents -> 字段Fields
ES集群可以包含多个索引(indices)（数据库），每一个索引库中可以包含多个类型(types)（表），每一个类型包含多个文档(documents)（行），然后每个文档包含多个字段(Fields)（列）。
创建索引文档
①使用自己的ID创建：
PUT {index}/{type}/{id}
{
"field": "value",
...
}
②ES内置ID创建：
POST {index}/{type}/
{
"field": "value",
...
}
①②ES响应内容：
{
"_index": "itsource",
"_type": "employee",
"_id": xxxxxx,
"_version": 1, //文档版本号
"created": true //是否新增
}
③ 获取指定ID的文档
GET itsource/employee/123?pretty --没有效果 经过格式化
③返回的内容：
{
"_index" : "itsource",
"_type" : "employee",
"_id" : "123",
"_version" : 1,
"found" : true,
"_source" : {
"email": "[email protected]",
"fullName": "老郑",
...
"joine_date": "2016-06-01"
}
}
返回文档的部分字段：
GET默认返回整个文档，通过GET /itsource/employee/123?_source=fullName,email
只返回文档内容，不要元数据：
GET itsource/employee/123/_source
④ 修改文档
更新整个文档
同post {index}/{type}/{id}
｛
Id:1,
Name:xx
｝
在响应中，我们可以看到Elasticsearch把 _version 增加了。
{
...
"_version" : 2,
"created": false
}
created 标识为 false 因为同索引、同类型下已经存在同ID的文档。
在内部，Elasticsearch已经标记旧文档为删除并添加了一个完整的新文档。旧版本文档不会立即消失，但你也不能去访问它。Elasticsearch会在你继续索引更多数据时清理被删除的文档。
局部更新文档
接受一个局部文档参数 doc，它会合并到现有文档中，对象合并在一起，存在的标量字段被覆盖，新字段被添加。
POST itsource/employee/123/_update
{
“doc”:{
"email" : "[email protected]",
"salary": 1000
}
}
email会被更新覆盖，salary会新增。
这个API 似乎 允许你修改文档的局部，但事实上Elasticsearch
遵循与之前所说完全相同的过程，这个过程如下：
1. 从旧文档中检索JSON
2. 修改它
3. 删除旧文档
4. 索引新文档
脚本更新文档 --了解
也可以通过使用简单的脚本来进行。这个例子使用一个脚本将age加5：
POST itsource/emploee/123/_update
{
"script" : "ctx._source.age += 5"
}
在上面的例子中， ctx._source指向当前被更新的文档。
注意，目前的更新操作只能一次应用在一个文档上。
删除文档
DELETE {index}/{type}/{id}
存在文档的返回：
{
"found" : true,
"_index" : "website",
"_type" : "blog",
"_id" : "123",
"_version" : 3
}
不存在的返回：
{
"found" : false,
"_index" : "website",
"_type" : "blog",
"_id" : "123",
"_version" : 4
}
注意：尽管文档不存在，但_version依旧增加了。这是内部记录的一部分，它确保在多节点间不同操作可以有正确的顺序。
批量操作bulk API -- 后台java程序api
使用单一请求来实现多个文档的create、index、update 或 delete。
Bulk请求体格式：
{ PUT: { metadata }}\n
{ request body }\n
{ action: { metadata }}\n
{ request body }\n
每行必须以 "\n" 符号结尾，包括最后一行。这些都是作为每行有效的分离而做的标记。
create当文档不存在时创建之。
index创建新文档或替换已有文档。
update局部更新文档。
delete删除一个文档。
例如：
POST _bulk
{ "delete": { "_index": "itsource", "_type": "employee", "_id": "123" }}
{ "create": { "_index": "itsource", "_type": "blog", "_id": "123" }}
{ "title": "我发布的博客" }
{ "index": { "_index": "itsource", "_type": "blog" }}
{ "title": "我的第二博客" }
注意：delete后不需要请求体，最后一行要有回车
8.3.文档的简单查询
8.3.1.通过文档ID获取
略
GET crm/employee/1
8.3.2.批量获取
mget API参数是一个 docs数组，数组的每个节点定义一个文档的 _index 、 _type 、 _id 元数据。如果你只想检索一个或几个确定的字段，也可以定义一个 _source 参数：
方式1：GET _mget （了解）
{
"docs" : [
{
"_index" : "itsource",
"_type" : "blog",
"_id" : 2
},
{
"_index" : "itsource",
"_type" : "employee",
"_id" : 1,
"_source": "email,age"
}
]
}
方式2：同一个索引库的同一个类型下 (掌握)
GET itsource/blog/_mget
{
"ids" : [ "2", "1" ]
}
8.3.3.空搜索
没有指定任何的查询条件，只返回集群索引中的所有文档： GET _search
8.3.4.分页搜索
和SQL使用 LIMIT 关键字返回只有一页的结果一样，Elasticsearch接受 from 和 size 参数：
size : 每页条数，默认 10
from : 跳过开始的结果数，默认 0
如果你想每页显示5个结果，页码从1到3，那请求如下：
GET _search?size=5
GET _search?size=5&from=5
GET _search?size=5&from=10
8.3.5 查询字符串搜索
一个搜索可以用纯粹的uri来执行查询。在这种模式下使用搜索，并不是所有的选项都是暴露的。它可以方便快速进行 curl 测试。
查询年龄为25岁的员工
GET itsource/employee/_search?q=age:25&size=5&from=10
age[20 TO 30]
现在我们条件比较少，直接在上面写条件，很舒服，如果我们添加比较多，上面的方式就是不适合
8.4.小结
本节主要是介绍了ES文档的表现形式以及文档的增删改查（简单）的基本操作。
9.ES查询
9.1.DSL查询
1.什么是DSL
由ES提供丰富且灵活的查询语言叫做DSL查询(Query DSL),它允许你构建更加复杂、强大的查询。
DSL(Domain Specific Language特定领域语言)以JSON请求体的形式出现。我们可以这样表示之前关于“老郑”的查询:
查询字符串模式(查询条件很少)：
GET itsource/employee/_search?q=fullName:老郑
DSL模式（查询条件很多）：
GET itsource/employee/_search
{
"query" : {
"match" : { //标准查询(分词查询 、模糊查询)
"fullName" : "赵郑"
}
}
}
通配符匹配
GET itsource/employee/_search
{
"query": {
"wildcard" : { //通配符查询
"name" : "*zs*" }
}
}
对于简单查询，使用查询字符串比较好，但是对于复杂查询，由于条件多，逻辑嵌套复杂，查询字符串不易组织与表达，且容易出错，因此推荐复杂查询通过DSL使用JSON内容格式的请求体代替。
DSL有两部分组成：DSL查询和DSL过滤
2.DSL查询
使用DSL查询，必须要传递query参数给ES。
GET _search
{“query”: YOUR_QUERY_HERE}
一个常用的相对完整的DSL查询：
GET itsource/employee/_search
{
"query": {
"match_all": {}
},
"from": 20,
"size": 10,
"_source": ["fullName", "age", "email"],
"sort": [{"join_date": "desc"},{"age": "asc"}]
}
上面查询 表示 查询所有数据，查询fullName，age和email，按照加入日期和年龄进行排序
3.DSL过滤
DSL过滤语句和DSL查询语句非常相似，但是它们的使用目的却不同 ：
DSL过滤 查询文档的方式更像是对于我的条件“有”或者“没有”，–精确查询
而DSL查询语句则像是“有多像”。–类似于模糊查询
DSL过滤和DSL查询在性能上的区别 ：
过滤结果可以缓存并应用到后续请求。
查询语句同时 匹配文档，计算相关性，所以更耗时，且不缓存。
过滤语句 可有效地配合查询语句完成文档过滤。
有点像如下关系：
where username like ‘%zs%’ and age = 11
where age = 11 and username like ‘%zs%’
原则上，使用DSL查询 做模糊查询 或其他需要进行相关性评分的场景，其它全用DSL过滤。
where (description = “hello world” ) and ( description like “%hello%” or description like “%java%” )
2.0以上的用法
Get index/type/_search
{
"query": {
"bool": { //booleanQuery 组合查询
"must": [ //查询 与(must) 或(should) 非(must not)
{
"match": {//标准查询(分词匹配) term：单词查询(部分词)
"description": "hello java"
}
}
],
"filter": { //过滤
"term": {"description": "hello world"}
}
}
},
"from": 20,
"size": 10,
"_source": ["fullName", "age", "email"],
"sort": [{"join_date": "desc"},{"age": "asc"}]
}
~~2.0以前的用法~~
{
"query": {
"filtered": {
"query": {
"match": {"description": "search" }
},
"filter": {
"term": {"tags": "lucene"}
}
}
}
}
4.使用DSL查询与过滤
① 全匹配（match_all）
普通搜索（匹配所有文档）：
{
"query" : {
"match_all" : {}
}
}
如果需要使用过滤条件（在所有文档中过滤，红色部分默认可不写）：
GET _search
{
"query": {
"bool": {
"must": [
{
"match_all": {}
}
],
"filter": {
"term": {
"name": "zs1"
}
}
}
}
}
② 标准查询（match和multi_match）
match查询是一个标准查询，不管你需要全文本查询还是精确查询基本上都要用到它。
如果你使用match查询一个全文本字段，它会在真正查询之前用分析器先分析查询字符：
{
"query": {
"match": {
"fullName": "Steven King"
}
}
}
上面的搜索会对Steven King分词，并找到包含Steven或King的文档，然后给出排序分值。
如果用 match 下指定了一个确切值，在遇到数字，日期，布尔值或者 not_analyzed的字符串时，它将为你搜索你给定的值，如：
{ "match": { "age": 26 }}
{ "match": { "date": "2014-09-01" }}
{ "match": { "public": true }}
{ "match": { "tag": "full_text" }}
multi_match 查询允许你做 match查询的基础上同时搜索多个字段：
{
"query":{
"multi_match": {
"query": "Steven King",
"fields": [ "fullName", "title" ]
}
}
}
where fullName = “Steven ”or fullName = “King”or title= “Steven ”or title= “King”
上面的搜索同时在fullName和title字段中匹配。
提示：match一般只用于全文字段的匹配与查询，一般不用于过滤。
③单词搜索与过滤（Term和Terms）
{
"query": {
"bool": {
"must": {
"match_all": {}
},
"filter": {
"term": {
"tags": "elasticsearch"
}
}
}
}
}
Terms搜索与过滤
{
"query": {
"terms": {
"tags": ["jvm", "hadoop", "lucene"],
"minimum_match": 1
}
}
}
minimum_match:至少匹配个数，默认为1
④ 组合条件搜索与过滤（Bool）
组合搜索bool可以组合多个查询条件为一个查询对象，查询条件包括must、should和must_not。
例如：查询爱好有美女，同时也有喜欢游戏或运动，且出生于1990-06-30及之后的人。
{
"query": {
"bool": {
"must": [{"term": {"hobby": "美女"}}],
"should": [{"term": {"hobby": "游戏"}},
{"term": {"hobby": "运动"}}
],
"must_not": [
{"range" :{"birth_date":{"lt": "1990-06-30"}}}
],
"filter": [...],
"minimum_should_match": 1
}
}
}
Hobby=美女 and （hobby=游戏 or hobby=运动) and birth_date >= 1990-06-30
提示： 如果 bool 查询下没有must子句，那至少应该有一个should子句。但是 如果有 must子句，那么没有 should子句也可以进行查询。
⑤ 范围查询与过滤（range）
range过滤允许我们按照指定范围查找一批数据:
{
"query":{
"range": {
"age": {
"gte": 20,
"lt": 30
}
}
}
}
上例中查询年龄大于等于20并且小于30。
gt:> gte:>= lt:< lte:<=
⑥ 存在和缺失过滤器（exists和missing）
{
"query": {
"bool": {
"must": [{
"match_all": {}
}],
"filter": {
"exists": { "field": "gps" }
}
}
}
}
提示：exists和missing只能用于过滤结果。
⑦ 前匹配搜索与过滤（prefix）
和term查询相似，前匹配搜索不是精确匹配，而是类似于SQL中的like ‘key%’
{
"query": {
"prefix": {
"fullName": "倪"
}
}
}
上例即查询姓倪的所有人。
⑧ 通配符搜索（wildcard）
使用*代表0~N个，使用?代表1个。
{
"query": {
"wildcard": {
"fullName": "倪*华"
}
}
}
9.2.高亮查询
高亮查询指的是可以给查询的结果中将查询的关键字进行高亮处理，比如加粗，上色等
GET hrm/course/_search
{
"query": {
"match": {
"name": "java"
}
},
"highlight": {
"fields": {
"name": {}
},
"pre_tags": "",
"post_tags": ""
}
}
9.3.聚合查询
1.Metrics Aggregations，指标聚合。
它是对文档进行一些权值计算（比如求所有文档某个字段求最大、最小、和、平均值），输出结果往往是文档的权值，相当于为文档添加了一些统计信息。
Max Aggregation:求最大值。基于文档的某个值计算该值在聚合文档中的均值。
Min Aggregation:求最小值。同上
Sum Aggregation:求和。同上
Avg Aggregation:求平均数。同上
Max Aggregation : 查询价格最大值
GET hrm/course/_search
{
"aggs": {
"price_max": {
"max": {
"field": "price"
}
}
}
}
其他三个函数用法一样
2.Value Count Aggregation，数量统计
Value Count Aggregation，值计数聚合。计算聚合文档中某个值（可以是特定的数值型字段，也可以通过脚本计算而来）的个数。该
聚合一般域其它 single-value 聚合联合使用，比如在计算一个字段的平均值的时候，可能还会关注这个平均值是由多少个值计算而来。
GET hrm/course/_search
{
"aggs": {
"id_count": {
"value_count": {
"field": "id"
}
}
}
}
3.distinct 去重聚合
Cardinality Aggregation，基数聚合。它属于multi-value，基于文档的某个值（可以是特定的字段，也可以通过脚本计算而来），计算文档非重复的个数（去重计数），相当于sql中的distinct。
GET hrm/course/_search
{
"aggs": {
"price_count": {
"cardinality": {
"field": "price"
}
},
"id_count": {
"cardinality": {
"field": "id"
}
}
}
}
4.统计聚合
Stats Aggregation，统计聚合。它属于multi-value，基于文档的某个值（可以是特定的数值型字段，也可以通过脚本计算而来），计算出一些统计信息（min、max、sum、count、avg5个值）。
GET hrm/course/_search
{
"aggs": {
"price_stats": {
"stats": {
"field": "price"
}
}
}
}
5.拓展的统计聚合
Extended Stats Aggregation，扩展统计聚合。它属于multi-value，比stats多4个统计结果： 平方和、方差、标准差、平均值加/减两个标准差的区间
GET hrm/course/_search
{
"aggs": {
"price_stats": {
"extended_stats": {
"field": "price"
}
}
}
}
6.Terms Aggregation 分组并统计数量
Terms Aggregation，词聚合。基于某个field，该 field 内的每一个【唯一词元】为一个桶，并计算每个桶内文档个数。默认返回顺序是按照文档个数多少排序。它属于multi-bucket。当不返回所有 buckets 的情况（它size控制），文档个数可能不准确。
统计在文档中某个字段的值出现的次数
GET hrm/course/_search
{
"aggs": {
"price_terms": {
"terms": {
"field": "price",
"size": 10
}
}
}
}
terms统计的是每种情况的条数是多少，SQL里面的 group by 后再 count
统计每个等级的数量以及价格平均值
统计每个等级的数量，且计算出每个等级的平均薪资
子聚合：根据机构ID聚合，然后再根据机构名字子聚合 ， 比如：要聚合出所有结果集中的机构ID，然后用子聚合的方式聚合出机构的名字，可以用来实现查询条件的联动，如京东的品牌联动查询条件
GET hrm/course/_search
{
"aggs": {
"tenantIdAgg": {
"terms": {
"field": "tenantId",
"size": 10
},
"aggs": {
"tenantNameAgg": {
"terms": {
"field": "tenantName",
"size": 10
}
}
}
}
}
}
7.Top Hits 最高匹配
Top Hits Aggregation，最高匹配权值聚合。获取到每组前n条数据，相当于sql 中Top（group by 后取出前n条）。它跟踪聚合中相关性最高的文档，该聚合一般用做 sub-aggregation，以此来聚合每个桶中的最高匹配的文档，较为常用的统计。
案例：统计每个价格的前10条数据
#分组统计数量
GET hrm/course/_search
{
"aggs": {
"price_terms": {
"terms": {
"field": "price",
"size": 100
},
"aggs": {
"tops": {
"top_hits": {
"size": 10
}
}
}
}
}
}
8.百分比排名聚合
Percentile Ranks Aggregation，统计price小于500和年龄小于600的文档的占比
GET hrm/course/_search
{
"aggs": {
"price_percentiles": {
"percentile_ranks": {
"field": "price",
"values": [
500,
600
]
}
}
}
}
9.4.小结
DSL查询是ES提供的通用查询方式，这种方式最大的特点是开发语言的无关性，即任意的客户端只要支持HTTP请求，就可以通过JSON格式的查询数据完成复杂的搜索。
查询与过滤在实际的项目开发中是经常遇到的主题。
10.分词与映射
10.1.为什么要使用分词与映射
在全文检索理论中，文档的查询是通过关键字查询文档索引来进行匹配，因此将文本拆分为有意义的单词，对于搜索结果的准确性至关重要，因此，在建立索引的过程中和分析搜索语句的过程中都需要对文本串分词。
ES中分词需要对具体字段指定分词器等细节，因此需要在文档的映射中明确指出。
10.2.IK分词器
ES默认对英文文本的分词器支持较好，但和lucene一样，如果需要对中文进行全文检索，那么需要使用中文分词器，同lucene一样，在使用中文全文检索前，需要集成IK分词器。
ES的IK分词器插件源码地址：
https://github.com/medcl/elasticsearch-analysis-ik
① Maven打包IK插件
② 解压target/releases/elasticsearch-analysis-ik-5.2.2.zip文件
并将其内容放置于ES根目录/plugins/ik
③ 配置插件：(不需要)
插件配置:plugin-descriptor.properties
④ 分词器（可默认）
词典配置：config/IKAnalyzer.cfg.xml
⑤ 重启ES
⑥ 测试分词器
POST _analyze
{
"analyzer":"ik_smart",
"text":"中国驻洛杉矶领事馆遭亚裔男子枪击 嫌犯已自首"
}
注意：IK分词器有两种类型，分别是ik_smart分词器和ik_max_word分词器。
ik_smart: 会做最粗粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,国歌”。
ik_max_word: 会将文本做最细粒度的拆分，比如会将“中华人民共和国国歌”拆分为“中华人民共和国,中华人民,中华,华人,人民共和国,人民,人,民,共和国,共和,和,国国,国歌”，会穷尽各种可能的组合；
10.3.文档映射Mapper
ES的文档映射(mapping)机制用于进行字段类型确认，将每个字段匹配为一种确定的数据类型。
1.ES字段类型
① 基本字段类型
字符串：text(分词),keyword(不分词) StringField(不分词文本),TextFiled(要分词文本)
text默认为全文文本，keyword默认为非全文文本
数字：long,integer,short,double,float
日期：date
逻辑：boolean
｛user:{“key”:value}｝
{hobbys:[xxx,xx]}
② 复杂数据类型
对象类型：object
数组类型：array
地理位置：geo_point,geo_shape
2.默认映射–掌握
查看索引类型的映射配置：GET {indexName}/_mapping/{typeName}
ES在没有配置Mapping的情况下新增文档，ES会尝试对字段类型进行猜测，并动态生成字段和类型的映射关系。
| JSON type | Field type |
|---|---|
| Boolean: true or false | “boolean” |
| Whole number: 123 | “long” |
| Floating point: 123.45 | “double” |
| String, valid date:“2014-09-15” | “date” |
| String: “foo bar” | “string” |
3.简单类型映射
字段映射的常用属性配置列表
| type | 类型：基本数据类型，integer,long,date,boolean,keyword,text… |
|---|---|
| enable | 是否启用：默认为true。 false：不能索引、不能搜索过滤，仅在_source中存储 |
| boost | 权重提升倍数：用于查询时加权计算最终的得分。 |
| format | 格式：一般用于指定日期格式，如 yyyy-MM-dd HH:mm:ss.SSS |
| ignore_above | 长度限制：长度大于该值的字符串将不会被索引和存储。 |
| ignore_malformed | 转换错误忽略：true代表当格式转换错误时，忽略该值，被忽略后不会被存储和索引。 |
| include_in_all | 是否将该字段值组合到_all中。 |
| null_value | 默认控制替换值。如空字符串替换为”NULL”，空数字替换为-1 |
| store | 是否存储：默认为false。true意义不大，因为_source中已有数据 |
| index | 索引模式：analyzed (索引并分词，text默认模式), not_analyzed (索引不分词，keyword默认模式)，no（不索引） |
| analyzer | 索引分词器：索引创建时使用的分词器，如ik_smart,ik_max_word,standard |
| search_analyzer | 搜索分词器：搜索该字段的值时，传入的查询内容的分词器。 |
| fields | 多字段索引：当对该字段需要使用多种索引模式时使用。如：城市搜索New York 下面字段city既可以分词有可以不分词"city": { “type”: “text”,“analyzer”: “ik_smart”,“fields”: {“raw”: { “type”: “keyword” } }} 有些类型 有时候需要分词 有时候不需要分词 city分词 city.raw不分词 那么以后搜索过滤和排序就可以使用city.raw字段名 match:{“city”:“北京”} match:{ “city.raw”:“北京”} |
① 针对单个类型的映射配置方式–掌握
查询映射类型：
GET shop/goods/_mapping
修改映射类型
（1）Delete shop;
（2）PUT shop;
（3）POST shop/goods/_mapping
{
"goods": {
"properties": {
"price": {
"type": "integer"
},
"name": {
"type": "text",
"analyzer": "ik_smart",
"search_analyzer": "ik_smart"
}
}
}
}
(4)加入数据
put shop/goods/1
{
"price":88,
"name": "iphone8"
}
注意：你可以在第一次创建索引的时候指定映射的类型。此外，你也可以晚些时候为新类型添加映射（或者为已有的类型更新映射）。
你可以向已有映射中增加字段，但你不能修改它。如果一个字段在映射中已经存在，这可能意味着那个字段的数据已经被索引。如果你改变了字段映射，那已经被索引的数据将错误并且不能被正确的搜索到。
我们可以更新一个映射来增加一个新字段，但是不能把已有字段的类型那个从 analyzed 改到 not_analyzed。
② 同时对多个类型的映射配置方式–了解
PUT {indexName}
{
"mappings": {
"user": {
"properties": {
"id": {
"type": "integer"
},
"info": {
"type": "text",
"analyzer": "ik_smart",
"search_analyzer"
}
}
},
"dept": {
"properties": {
"id": {
"type": "integer"
},
....更多字段映射配置
}
}
}
}
4.对象及数组类型映射–了解
① 对象的映射与索引
{
“id” : 1,
“girl” : {
“name” : “王小花”,
“age” : 22
}
}
对应的mapping配置：
{
"properties": {
"id": {"type": "long"},
"girl": {
"properties":{
"name": {"type": "keyword"},
"age": {"type": "integer"}
}
}
}
}
② 数组与对象数组
注意：数组中元素的类型必须一致。
{
“id” : 1,
“hobby” : [“王小花”,“林志玲”]
}
对应的mapping配置是：
{
"properties": {
"id": {"type": "long"},
"hobby": {"type": "keyword"}
}
}
对象数组的映射–用不上
{
"id" : 1,
"girl":[{"name":"林志玲","age":32},{"name":"赵丽颖","age":22}]
}
对应的映射配置为：
"properties": {
"id": {
"type": "long"
},
"girl": {
"properties": {
"age": { "type": "long" },
"name": { "type": "text" }
}
}
}
注意：同内联对象一样，对象数组也会被扁平化索引
{
"user1.girl.age": [32, 22],
"user2.girl.name": ["林志玲", "赵丽颖"]
}
6.全局映射
全局映射可以通过动态模板和默认设置两种方式实现。
默认方式：default(了解)
索引下所有的类型映射配置会继承_default_的配置，如：
PUT {indexName}
{
"mappings": {
"_default_": {
"_all": {
"enabled": false 关闭默认映射配置
}
},
"user": {
//指定自己的自定义配置
},
"dept": {
"_all": {
"enabled": true //启动默认配置
}
},
....
}
}
上例中：默认的enabled=false 表示关闭模式的配置，如果你想用，在自己的配置里面开启配置
动态模板：dynamic_templates
注意：ES会默认把string类型的字段映射为text类型（默认使用标准分词器）和对应的keyword类型，如：
"name": {
"type": "text",
"fields": {
"keyword": {
"type": "keyword",
"ignore_above": 256
}
}
}
在实际应用场景中，一个对象的属性中，需要全文检索的字段较少，大部分字符串不需要分词，因此，需要利用全局模板覆盖自带的默认模板：
PUT _template/global_template //创建名为global_template的模板
{
"template": "*", //匹配所有索引库
"settings": { "number_of_shards": 1 }, //匹配到的索引库只创建1个主分片
"mappings": {
"_default_": {
"_all": {
"enabled": false //关闭所有类型的_all字段
},
"dynamic_templates": [ username:“zs”
{
"string_as_text": {
"match_mapping_type": "string",//匹配类型string
"match": "*_text", //匹配字段名字以_text结尾 a_text
"mapping": {
"type": "text",//将类型为string的字段映射为text类型
"analyzer": "ik_max_word",
"search_analyzer": "ik_max_word",
"fields": {
"raw": {
"type": "keyword",
"ignore_above": 256
}
}
}
}
},
{
"string_as_keyword": {
"match_mapping_type": "string",//匹配类型string
"mapping": {
"type": "keyword"//将类型为string的字段映射为keyword类型
}
}
}
]
}
}}
上面的意思：就是如果索引库里面字段 以_text结尾 就需要进行分词，如果不是，就不分词
测试：
(1)拷贝上面代码执行
(2)删除库 delete shop
(3)创建库 put shop
(4)加入数据测试
POST shop/goods/5
{
“id”:12,
“name_text”:”iphone x”，
“local“:”cnsssss”
}
说明：上例中定义了两种动态映射模板string_as_text和string_as_keyword.
在实际的类型字段映射时，会依次匹配：
①字段自定义配置
②全局配置
③默认配置
7.最佳实践
（1）有数据不做映射
（2）根据优先级来
步骤(1)如果有库 先删除库
(2)建库
(3)做全局映射
(4)做自定义映射
(5)操作crud
11.Java操作ES
11.1.集成ES
1.导入依赖
ES对Java提供一套操作索引库的工具包，即Java API。所有的ES操作都使用Client对象执行。
ES的Maven引入
<dependency>
<groupId>org.elasticsearch.clientgroupId>
<artifactId>transportartifactId>
<version>5.2.2version>
dependency>
<dependency>
<groupId>org.apache.logging.log4jgroupId>
<artifactId>log4j-apiartifactId>
<version>2.7version>
dependency>
<dependency>
<groupId>org.apache.logging.log4jgroupId>
<artifactId>log4j-coreartifactId>
<version>2.7version>
dependency>
2.连接ES获取Client对象
方式一： 把每台服务的ip 端口配上
TransportClient 利用transport模块远程连接一个ES集群。它并不加入到集群中，只是简单的获得一个或者多个初始化的transport地址，并以轮询的方式与这些地址进行通信。
// on startup
TransportClient client = new PreBuiltTransportClient(Settings.EMPTY)
.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("host1"), 9300))
.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("host2"), 9300));
// on shutdown
client.close();
方式二：通过集群名称来查找
注意，如果你有一个与 ES集群不同的集群，你可以设置机器的名字。
Settings settings = Settings.builder()
.put("cluster.name", "myClusterName").build();
TransportClient client = new PreBuiltTransportClient(settings);
//添加地址到client中
方式三: 推荐使用方式
你可以设置client.transport.sniff为true来使客户端去嗅探整个集群的状态，把集群中其它机器的ip地址加到客户端中，这样做的好处是一般你不用手动设置集群里所有集群的ip到连接客户端，它会自动帮你添加，并且自动发现新加入集群的机器。代码实例如下：
Settings settings = Settings.builder()
.put("client.transport.sniff", true).build();
TransportClient client = new PreBuiltTransportClient(settings)
.addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("127.0.0.1"), 9300))
11.2.crud实现
1.创建文档索引
ES索引文档非常方便，只需要构建好需要索引的JSON格式数据，然后调用API：
import static org.elasticsearch.common.xcontent.XContentFactory.*;
IndexResponse response = client.prepareIndex("crm", "vip", "1")
.setSource(jsonDataText).get();
或使用ES自动ID，不提供ID值1也OK。
返回的response对象可以获取到_index,_type,_version,_id等元数据。
2.获取文档
GetResponse response = client.prepareGet(“crm”, “vip”, “1”).get();
3.更新文档
client.prepareUpdate("crm", "vip", "1").setDoc("{\"sex\":0}").get();
或client.prepareUpdate("crm", "vip", "1")
.setScript(new Script("ctx._source.sex = 1" , ScriptService.ScriptType.INLINE,null, null))
.get();
java API也支持使用 upsert。如果文档还不存在，会根据 upsert内容创建一个新的索引。
--不用上面的代码 ，使用下面的代码
IndexRequest indexRequest = new IndexRequest("crm", "vip", "1")
.source(originalJsonData);
UpdateRequest updateRequest = new UpdateRequest("crm", "vip", "1")
.doc(updateJsonData).upsert(indexRequest);
client.update(updateRequest).get();
4.删除文档
DeleteResponse response = client.prepareDelete("crm", "vip", "1").get();
5.批量操作
BulkRequestBuilder bulkRequest = client.prepareBulk();
bulkRequest.add(client.prepareIndex("crm", "vip", "1")
.setSource(vip1JsonData));
bulkRequest.add(client.prepareIndex("crm", "vip", "2")
.setSource(vip2JsonData));
BulkResponse bulkResponse = bulkRequest.get();
if (bulkResponse.hasFailures()) {
//处理错误
}
6.搜索
ES的查询是通过执行json格式的查询条件，在java中就是构造QueryBuilder对象，ES完全支持queryDSL风格的查询方式，QueryBuilder的构建类是QueryBuilders，filter的构建类是FilterBuilders。
查询示例：
@Test
public void testDsl()throws Exception{
TransportClient client = getClient();
//prepareSearch
SearchRequestBuilder builder = client.prepareSearch(“crm”) //库
.setTypes(“blog”); //DSL过滤bool 表
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//must
List<QueryBuilder> must = boolQuery.must(); //query bool must
must.add(QueryBuilders.matchAllQuery()); //可以添加多个
//filter
boolQuery.filter(QueryBuilders.rangeQuery("age").gte(10).lte(50));//query bool filter
//query
builder.setQuery(boolQuery); //query bool
//排序
builder.addSort("age", SortOrder.ASC);
//分页
builder.setFrom(10).setSize(10);
//截取字段
builder.setFetchSource(new String[]{"id","age"},null);
//展示内容
SearchResponse response = builder.get();
//获取总数
SearchHits hits = response.getHits(); //搜索出来东西都放到这个对象里面,里面包含总数+数据
System.out.println("总数:"+hits.totalHits());
//获取当前数据
SearchHit[] searchHits = hits.getHits();
for (SearchHit searchHit : searchHits) {
System.out.println(searchHit.getSource());
}
}
12.SpringBoot操作ES
12.1.SpringBoot集成ES
1.导入依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-data-elasticsearchartifactId>
dependency>
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-testartifactId>
dependency>
2.配置ES
...
spring:
application:
name: hrm-es-server
data:
elasticsearch:
cluster-name: elasticsearch
cluster-nodes: 127.0.0.1:9300 #9200是图形界面端,9300代码端
...
3.创建ES的文档对象
以前做文档映射如下：
POST hrm;
Post /hrm/employee/_mapping
{
“employee”:{
“properties”:{
“id”:{
“type”:”long”
},
“userName”:{
“type”:”keyword”
},
“Intro”:{
“type”:”text”,
“analyzer ”: "ik_max_word"
}
}
}
}
Pub /hrm/employee/1
{
Id:1,
userName：“zs”,
Age: 18，
Intro：“”
}
该文档对象用来如下几个事情
索引库的创建
文档的映射
存储到ES的数据封装
/**
* 针对于 Employee 表的文档映射
* indexName：索引库
* type：类型(表类型)
*/
@Document(indexName = "hrm" , type = "employee")
public class EmployeeDoc {
//对应文档的id PUT /index/type/id
@Id
private Long id;
@Field(type = FieldType.Keyword) //指定为 不分词
private String userName;
private int age;
@Field(type =FieldType.Text,analyzer = "ik_max_word",searchAnalyzer = "ik_max_word")
private String intro;
...
4.初始化索引库和文档映射
@RunWith(SpringRunner.class)
@SpringBootTest(classes = EsServiceApplication2050.class)
public class ESTest {
@Autowired
private ElasticsearchTemplate elasticsearchTemplate;
@Test
public void testCreateIndex() {
//创建索引
elasticsearchTemplate.createIndex(EmployeeDoc.class);
//做文档映射
elasticsearchTemplate.putMapping(EmployeeDoc.class);
}
}
5.定义Repository
@Repository
public interface EmployeeElasticsearchRepository extends ElasticsearchRepository<EmployeeDoc,Long> {}
12.2.CRUD实现
1.添加数据
//文档的添加
@Test
public void testDocumentAdd(){
for(long i = 1 ; i < 30 ; i++){
CourseDoc doc = new CourseDoc();
doc.setId(i);
if(i % 2 == 0){
doc.setName("php小神班");
doc.setPrice(1000.00F);
}else{
doc.setName("java小神班");
doc.setPrice(1000.00F+i*100);
}
courseElasticsearchRepository.save(doc);
System.out.println("保存成功....");
}
}
2.修改数据
修改和添加一样，如果该id已经存在，就是修改
3.删除数据
//文档的删除
@Test
public void testDocumentDelete(){
courseElasticsearchRepository.deleteById(1L);
System.out.println("删除成功....");
testDocumentGet();
}
4.获取数据
//文档的获取
@Test
public void testDocumentGet(){
Optional<CourseDoc> optional = courseElasticsearchRepository.findById(1L);
CourseDoc courseDoc = optional.get();
System.out.println(courseDoc);
}
5.高级查询
//需求：查询课程名 name 中包含 java ： DSL查询 - must - match
// 价格 price 在 1000 - 3000 ： DSL过滤 - filter - range
// 每页 10 条，取第一页 ，按照价格倒排
@Test
public void testSearch(){
//创建一个本机查询builder
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
//=================================================
//1.查询条件
//组合查询
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
//查询课程名 name 中包含 java ： DSL查询 - must - match
boolQueryBuilder.must(QueryBuilders.matchQuery("name","php"));
//价格 price 在 1000 - 3000 ： DSL过滤 - filter - range
boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(1000).lte(3000));
builder.withQuery(boolQueryBuilder);
//2.排序 按照价格倒排
builder.withSort(new FieldSortBuilder("price").order(SortOrder.DESC));
//3.分页
builder.withPageable(PageRequest.of(0,10));
//=================================================
//构建一个查询对象
NativeSearchQuery searchQuery = builder.build();
//执行查询，得到结果
Page<CourseDoc> page = courseElasticsearchRepository.search(searchQuery);
//page -> PageList
System.out.println("总条数："+page.getTotalElements());
System.out.println("总页数："+page.getTotalPages());
//结果列表
List<CourseDoc> content = page.getContent();
content.forEach(courseDoc -> {
System.out.println(courseDoc);
});
}
13.高亮
13.1.创建结果处理器
在SpringBootDataES包中SearchResultMapper
默认没有对高亮进行结果处理，我们需要自己进行高亮转换，如下：
@Component
public class HighlightResultMapper implements SearchResultMapper {
@Override
public <T> AggregatedPage<T> mapResults(SearchResponse response, Class<T> aClass, Pageable pageable) {
// 记录总条数
long totalHits = response.getHits().getTotalHits();
// 记录列表(泛型) - 构建Aggregate使用
List<T> list = Lists.newArrayList();
// 获取搜索结果(真正的的记录)
SearchHits hits = response.getHits();
for (SearchHit hit : hits) {
if(hits.getHits().length <= 0){
return null;
}
// 将原本的JSON对象转换成Map对象
Map<String, Object> map = hit.getSourceAsMap();
// 获取高亮的字段Map
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
for (Map.Entry<String, HighlightField> highlightField : highlightFields.entrySet()) {
// 获取高亮的Key
String key = highlightField.getKey();
// 获取高亮的Value
HighlightField value = highlightField.getValue();
// 实际fragments[0]就是高亮的结果，无需遍历拼接
Text[] fragments = value.getFragments();
StringBuilder sb = new StringBuilder();
for (Text text : fragments) {
sb.append(text);
}
// 因为高亮的字段必然存在于Map中，就是key值
// 可能有一种情况，就是高亮的字段是嵌套Map，也就是说在Map里面还有Map的这种情况，这里没有考虑
map.put(key, sb.toString());
}
// 把Map转换成对象
T item = JSON.parseObject(JSONObject.toJSONString(map),aClass);
list.add(item);
}
// 返回的是带分页的结果
return new AggregatedPageImpl<>(list, pageable, totalHits);
}
}
13.2.高亮查询
@RunWith(SpringRunner.class)
@SpringBootTest(classes = SearchApplication1080.class)
public class ESTest {
@Autowired
private ElasticsearchTemplate template;
@Autowired
private HighlightResultMapper highlightResultMapper ;
@Autowired
private CourseElasticsearchRepository repository;
@Test
public void testSearchDoc(){
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
...省略...
//设置高亮显示===========================================
HighlightBuilder.Field field = new HighlightBuilder.Field("name").preTags("").postTags("");
builder.withHighlightFields(field); // 名字高亮
NativeSearchQuery build = builder.build();
//执行查询 ,使用ElasticSearchTemplate,查询， highlightResultMapper指定结果处理映射器
Page<CourseDoc> page =
template.queryForPage(builder.build(),CourseDoc.class,highlightResultMapper);
System.out.println("总条数："+page.getTotalElements());
System.out.println("总页数："+page.getTotalPages());
page.getContent().forEach(doc->{
System.out.println(doc);
});
}
}
14.聚合查询
14.1.修改结果映射器
添加聚合结果
@Component
public class HighlightResultMapper implements SearchResultMapper {
@Override
public <T> AggregatedPage<T> mapResults(SearchResponse response, Class<T> aClass, Pageable pageable) {
...省略...
// 返回的是带分页的结果
return new AggregatedPageImpl<>(list, pageable, totalHits,response.getAggregations());
}
}
14.2.聚合查询
@Test
public void testSearchDoc(){
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
// 每页 10 条，取第 1 页 ，
builder.withPageable(PageRequest.of(0,10));
// 按照价格 price 倒排
builder.withSort(new FieldSortBuilder("price").order(SortOrder.DESC));
//查询条件
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery() ;//new BoolQueryBuilder();
//must : name 中包含 "java" : match
//boolQueryBuilder.must(QueryBuilders.termQuery("name","java"));
//filter ： 价格 price 在 1000 - 3000 ：
//boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(1000).lte(3000));
builder.withQuery(boolQueryBuilder);
//设置高亮显示
HighlightBuilder.Field field = new HighlightBuilder.Field("name").preTags("").postTags("");
builder.withHighlightFields(field); // 名字高亮
NativeSearchQuery build = builder.build();
//聚合查询
TermsAggregationBuilder tenantAgg = AggregationBuilders.terms("tenantAgg").field("tenantName")
.order(Terms.Order.count(false)).size(50); //按照count倒排
builder.addAggregation(tenantAgg);
//执行查询
AggregatedPage<CourseDoc> page = template.queryForPage(builder.build(),CourseDoc.class,esResultMapper);
System.out.println("总条数："+page.getTotalElements());
System.out.println("总页数："+page.getTotalPages());
page.getContent().forEach(doc->{
System.out.println(doc);
});
//获取聚合结果
StringTerms terms = (StringTerms) page.getAggregation("tenantAgg");
List<StringTerms.Bucket> buckets = terms.getBuckets();
//把机构名字聚合，搜集成字符串里集合
List<String> tenantNames = buckets.stream().map(bucket -> bucket.getKeyAsString()).collect(Collectors.toList());
System.out.println(tenantNames);
}
15.总结
1.重点
索引创建原理(分词)
Lucene的入门
ES文档的CRUD
ES查询与过滤
ES分词与映射
Java操作ES
2.作业
全天代码