es的结构（索引，类型，文档，属性）
倒排索引
将存放的数据，以一定的方式进行分词，并且将分词的内容存放到一个单独的分词库中。
当用户去查询数据时，会将用户的查询关键字进行分词。
然后去分词库中匹配内容，最终得到数据的id标识。
根据id标识去存放数据的位置拉取到指定的数据。
索引
ES的服务中，可以创建多个索引。每一个索引默认被分成5片存储。每一个分片都会存在至少一个备份分片。备份分片默认不会帮助检索数据，当ES检索压力特别大的时候，备份分片才会帮助检索数据。备份的分片必须放在不同的服务器中。
**类型 Type **
一个索引下，可以创建多个类型。
根据版本不同，类型的创建也不同
文档 Doc—行
一个类型下，可以有多个文档。这个文档就类似于MySQL表中的多行数据。
属性 Field–列
一个文档中，可以包含多个属性。类似于MySQL表中的一行数据存在多个列
操作ES的RESTful语法（javaREST风格）
注意！要一级一级的操作（要操作文档就要把前边的索引和类型加上）
GET请求：查索引 http://ip:port/index：查询索引信息—+++查索引http://ip:port/index/type/doc_id：查询指定的文档信息—+++查id POST请求：查某一条，（当做添加文档，自动生成id时也用这个手动生成id的时候用 put） http://ip:port/index/type/_search：查询文档，可以在请求体中添加json字符串来代表查询条件—+++查（加条件查询加query）http://ip:port/index/type/doc_id/_update：修改文档，在请求体中指定json字符串代表修改的具体信息—+++改（根据id改指定的doc文档）http://ip:port/index/type：增加操作，可以自动生成id PUT请求：增（创建索引） http://ip:port/index：创建一个索引，需要在请求体中指定索引的信息，类型，结构—+++增索引http://ip:port/index/type/_mappings：代表创建索引时，指定索引文档存储的属性的信息—+++增（为已有索引增mapping，fired） DELETE请求：删 http://ip:port/index：删除索引http://ip:port/index/type/doc_id：删除指定的文档
ES中Field可以指定的类型
字符串类型：
text：一把被用于全文检索。 将当前Field进行分词。keyword：当前Field不会被分词。
数值类型：
long：取值范围为-9223372036854774808~922337203685477480(-2的63次方到2的63次方-1)，占用8个字节integer：取值范围为-2147483648~2147483647(-2的31次方到2的31次方-1)，占用4个字节short：取值范围为-32768~32767(-2的15次方到2的15次方-1)，占用2个字节byte：取值范围为-128~127(-2的7次方到2的7次方-1)，占用1个字节double：1.797693e+308~ 4.9000000e-324 (e+308表示是乘以10的308次方，e-324表示乘以10的负324次方)占用8个字节float：3.402823e+38 ~ 1.401298e-45(e+38表示是乘以10的38次方，e-45表示乘以10的负45次方)，占用4个字节half_float：精度比float小一半。scaled_float：根据一个long和scaled来表达一个浮点型，long-345，scaled-100 -> 3.45
时间类型：
date类型，针对时间类型指定具体的格式
布尔类型：
boolean类型，表达true和false
二进制类型：
binary类型暂时支持Base64 encode string
范围类型：
long_range：赋值时，无需指定具体的内容，只需要存储一个范围即可，指定gt，lt，gte，lteinteger_range：同上double_range：同上float_range：同上date_range：同上ip_range：同上
经纬度类型：
geo_point：用来存储经纬度的
ip类型：
ip：可以存储IPV4或者IPV6
其他的数据类型参考官网：https://www.elastic.co/guide/en/elasticsearch/reference/6.5/mapping-types.html
实例
1，创建索引并指定数据结构（必须包含：分片备份，类型，属性）
# 创建索引，指定数据结构PUT /book{"settings": {# 分片数"number_of_shards": 5,# 备份数"number_of_replicas": 1},# 指定数据结构"mappings": {# 类型 Type"novel": {# 文档存储的Field"properties": {# Field属性名"name": {# 类型"type": "text",# 指定分词器"analyzer": "ik_max_word",# 指定当前Field可以被作为查询的条件"index": true ,# 是否需要额外存储"store": false },"author": {"type": "keyword"},"count": {"type": "long"},"on-sale": {"type": "date",# 时间类型的格式化方式 "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"},"descr": {"type": "text","analyzer": "ik_max_word"}}}}}
2，文档的操作
新建文档
# 添加文档，自动生成id#自动生成的id：P59BbXQBQN3Zxx-BQCXmPOST /book/novel{"id":1,"name": "盘龙","author": "我吃西红柿","count": 100000,"on-sale": "2000-01-01","descr": "山重水复疑无路，柳暗花明又一村"}# 添加文档，手动指定idPUT /book/novel/1{"name": "红楼梦","author": "曹雪芹","count": 10000000,"on-sale": "1985-01-01","descr": "一个是阆苑仙葩，一个是美玉无瑕"}
修改文档
1，覆盖式修改# 添加文档，手动指定idPUT /book/novel/1{"name": "红楼梦","author": "曹雪芹","count": 4353453,"on-sale": "1985-01-01","descr": "一个是阆苑仙葩，一个是美玉无瑕"}2，doc的修改方式# 修改文档，基于doc方式POST /book/novel/1/_update{"doc": {# 指定上需要修改的field和对应的值"count": "1234565"}}
删除文档
# 根据id删除文档DELETE /book/novel/_id5
查询文档（重点）
1，创建连接
public class EsClient {public static RestHighLevelClient getEsClient() {//创建连接// 创建HttpHost对象HttpHost httpHost = new HttpHost("192.168.32.137", 9200);// 创建RestClientBuilderRestClientBuilder builder = RestClient.builder(httpHost);// 创建RestHighLevelClientRestHighLevelClient client = new RestHighLevelClient(builder);return client;}}
文档操作的代码实现
public class JavaEsTest {// 先定义连接对选哪个，并设置索引和类型后边会多次用到private RestHighLevelClient client = EsClient.getEsClient();private String index = "book";private String type = "fantasy";// 创建索引+++++++索引的操作@Testpublic void createIndex() throws IOException {// 1需要先setting设置分片，备份Settings.Builder settings = Settings.builder().put("number_of_shards", 5).put("number_of_replicas", 1);// 2 需要书写类型映射mappingXContentBuilder mappings = JsonXContent.contentBuilder();mappings.startObject().startObject("properties").startObject("bookName").field("type", "text").field("analyzer", "ik_max_word").field("index", "true").endObject().startObject("id").field("type", "long").endObject().startObject("bookAuthor").field("type", "keyword").endObject().startObject("bookCreateTime").field("type", "date").field("format", "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd").endObject().startObject("bookDesc").field("type", "text").field("analyzer", "ik_max_word").endObject().startObject("bookSize").field("type", "long").endObject().endObject().endObject();// 3将设置好的setting和mapping设置到请求对象中// 创建一个创建索引的请求对象,CreateIndexRequest request = new CreateIndexRequest(index);request.settings(settings);request.mapping(type, mappings);// 4执行创建索引操作==响应CreateIndexResponse response = client.indices().create(request, RequestOptions.DEFAULT);boolean acknowledged = response.isAcknowledged();System.out.println(acknowledged);}@Test//查看某一个索引存在不存在public void indexExsist() throws IOException {GetIndexRequest request = new GetIndexRequest();request.indices(index);boolean b = client.indices().exists(request, RequestOptions.DEFAULT);System.out.println(b);}@Test//索引的删除？public void indexDelete() throws IOException {DeleteIndexRequest request = new DeleteIndexRequest(index);AcknowledgedResponse response = client.indices().delete(request, RequestOptions.DEFAULT);System.out.println(response.isAcknowledged());}//文档的操作(文档操作就要指明索引和类型)@Testpublic void addDoc() throws IOException {IndexRequest request = new IndexRequest(index, type);String desc = "这里是倒流澳大利亚那才叫还打";Book book = new Book("斗破苍穹", "天蚕土豆", 1L, desc, "-09-09", 20000000L);// 设置添加的值String jsonStr = JSON.toJSONString(book);System.out.println(jsonStr);request.source(jsonStr, XContentType.JSON);IndexResponse index = client.index(request, RequestOptions.DEFAULT);System.out.println(index);}//文档修改@Testpublic void updateDoc() throws IOException {UpdateRequest request = new UpdateRequest(index, type, "Rp8FbnQBQN3Zxx-BcCUz");String desc = "这里是倒流澳大利亚那才叫还打";Book book = new Book("斗破苍穹", "di蚕土豆", 1L, desc, "-09-09", 20000000L);// 设置添加的值String jsonStr = JSON.toJSONString(book);System.out.println(jsonStr);request.doc(jsonStr, XContentType.JSON);UpdateResponse update = client.update(request, RequestOptions.DEFAULT);}//文档删除@Testpublic void deleteDoc() throws IOException {DeleteRequest request = new DeleteRequest(index, type, "Rp8FbnQBQN3Zxx-BcCUz");DeleteResponse delete = client.delete(request, RequestOptions.DEFAULT);System.out.println(delete);}// 批量操作添加@Testpublic void bulkCreateDoc() throws IOException {//准备多个jsonString desc = "这里是倒流澳大利亚那才叫还打";Book book1 = new Book("少年1", "di蚕土豆", 1L, desc, "-09-09", 20000000L);Book book2 = new Book("少年2", "di蚕土豆", 2L, desc, "-09-09", 20000000L);Book book3 = new Book("少年3", "di蚕土豆", 3L, desc, "-09-09", 20000000L);String jsonStr1 = JSON.toJSONString(book1);String jsonStr2 = JSON.toJSONString(book2);String jsonStr3 = JSON.toJSONString(book3);//创建request封装jsonBulkRequest request = new BulkRequest();request.add(new IndexRequest(index, type, book1.getId().toString()).source(jsonStr1, XContentType.JSON));request.add(new IndexRequest(index, type, book2.getId().toString()).source(jsonStr2, XContentType.JSON));request.add(new IndexRequest(index, type, book3.getId().toString()).source(jsonStr3, XContentType.JSON));// 用client执行BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);//4. 输出结果System.out.println(resp.toString());}//批量删除@Testpublic void bulkDeleteDoc() throws IOException {// 1封装request 对象BulkRequest request = new BulkRequest();request.add(new DeleteRequest(index, type, "1"));request.add(new DeleteRequest(index, type, "2"));request.add(new DeleteRequest(index, type, "3"));//cliient执行BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);//3输出System.out.println(resp);}}
六、 ElasticSearch的各种查询
6.1 term&terms查询【重点】
6.1.1 term查询
term的查询是代表完全匹配，搜索之前不会对你搜索的关键字进行分词，对你的关键字去文档分词库中去匹配内容。
# term查询POST /sms-logs-index/sms-logs-type/_search{"from": 0,# limit ？"size": 5, # limit x,?"query": {"term": {"province": {"value": "北京"}}}}
代码实现方式
// Java代码实现方式@Testpublic void termQuery() throws IOException {//1. 创建Request对象SearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.from(0);builder.size(5);builder.query(QueryBuilders.termQuery("province","北京"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 获取到_source中的数据，并展示for (SearchHit hit : resp.getHits().getHits()) {Map<String, Object> result = hit.getSourceAsMap();System.out.println(result);}}
6.1.2 terms查询
terms和term的查询机制是一样，都不会将指定的查询关键字进行分词，直接去分词库中匹配，找到相应文档内容。
terms是在针对一个字段包含多个值的时候使用。
term：where province = 北京；
terms：where province = 北京 or province = ？or province = ？
# terms查询POST /sms-logs-index/sms-logs-type/_search{"query": {"terms": {"province": ["北京","山西","武汉"]}}}
代码实现方式
// Java实现@Testpublic void termsQuery() throws IOException {//1. 创建requestSearchRequest request = new SearchRequest(index);request.types(type);//2. 封装查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.query(QueryBuilders.termsQuery("province","北京","山西"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出_sourcefor (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.2 match查询【重点】
match查询属于高层查询，他会根据你查询的字段类型不一样，采用不同的查询方式。
查询的是日期或者是数值的话，他会将你基于的字符串查询内容转换为日期或者数值对待。如果查询的内容是一个不能被分词的内容（keyword），match查询不会对你指定的查询关键字进行分词。如果查询的内容时一个可以被分词的内容（text），match会将你指定的查询内容根据一定的方式去分词，去分词库中匹配指定的内容。
match查询，实际底层就是多个term查询，将多个term查询的结果给你封装到了一起。
6.2.1 match_all查询
查询全部内容，不指定任何查询条件。
# match_all查询POST /sms-logs-index/sms-logs-type/_search{"query": {"match_all": {}}}
代码实现方式
// java代码实现@Testpublic void matchAllQuery() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.query(QueryBuilders.matchAllQuery());builder.size(20); // ES默认只查询10条数据，如果想查询更多，添加sizerequest.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}System.out.println(resp.getHits().getHits().length);}
6.2.2 match查询
指定一个Field作为筛选的条件
# match查询POST /sms-logs-index/sms-logs-type/_search{"query": {"match": {"smsContent": "收货安装"}}}
代码实现方式
@Testpublic void matchQuery() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//-----------------------------------------------builder.query(QueryBuilders.matchQuery("smsContent","收货安装"));//-----------------------------------------------request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.2.3 布尔match查询
基于一个Field匹配的内容，采用and或者or的方式连接
# 布尔match查询POST /sms-logs-index/sms-logs-type/_search{"query": {"match": {"smsContent": {"query": "中国 健康","operator": "and"# 内容既包含中国也包含健康}}}}# 布尔match查询POST /sms-logs-index/sms-logs-type/_search{"query": {"match": {"smsContent": {"query": "中国 健康","operator": "or"# 内容包括健康或者包括中国}}}}
代码实现方式
// Java代码实现@Testpublic void booleanMatchQuery() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//----------------------------------------------- 选择AND或者ORbuilder.query(QueryBuilders.matchQuery("smsContent","中国 健康").operator(Operator.OR));//-----------------------------------------------request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.2.4 multi_match查询
match针对一个field做检索，multi_match针对多个field进行检索，多个field对应一个text。
# multi_match 查询POST /sms-logs-index/sms-logs-type/_search{"query": {"multi_match": {"query": "北京",# 指定text"fields": ["province","smsContent"] # 指定field们}}}
代码实现方式
// java代码实现@Testpublic void multiMatchQuery() throws IOException {//1. 创建RequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//-----------------------------------------------builder.query(QueryBuilders.multiMatchQuery("北京","province","smsContent"));//-----------------------------------------------request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.3 其他查询
6.3.1 id查询
根据id查询 where id = ?
# id查询GET /sms-logs-index/sms-logs-type/1
代码实现方式
// Java代码实现@Testpublic void findById() throws IOException {//1. 创建GetRequestGetRequest request = new GetRequest(index,type,"1");//2. 执行查询GetResponse resp = client.get(request, RequestOptions.DEFAULT);//3. 输出结果System.out.println(resp.getSourceAsMap());}
6.3.2 ids查询
根据多个id查询，类似MySQL中的where id in（id1，id2，id2…）
# ids查询POST /sms-logs-index/sms-logs-type/_search{"query": {"ids": {"values": ["1","2","3"]}}}
代码实现方式
// Java代码实现@Testpublic void findByIds() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//----------------------------------------------------------builder.query(QueryBuilders.idsQuery().addIds("1","2","3"));//----------------------------------------------------------request.source(builder);//3. 执行SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.3.3 prefix查询
前缀查询，可以通过一个关键字去指定一个Field的前缀，从而查询到指定的文档。
#prefix 查询POST /sms-logs-index/sms-logs-type/_search{"query": {"prefix": {"corpName": {"value": "途虎"}}}}
代码实现方式
// Java实现前缀查询@Testpublic void findByPrefix() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//----------------------------------------------------------builder.query(QueryBuilders.prefixQuery("corpName","盒马"));//----------------------------------------------------------request.source(builder);//3. 执行SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.3.4 fuzzy查询
模糊查询，我们输入字符的大概，ES就可以去根据输入的内容大概去匹配一下结果。
# fuzzy查询POST /sms-logs-index/sms-logs-type/_search{"query": {"fuzzy": {"corpName": {"value": "盒马先生","prefix_length": 2# 指定前面几个字符是不允许出现错误的}}}}
代码实现方式
// Java代码实现Fuzzy查询@Testpublic void findByFuzzy() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//----------------------------------------------------------builder.query(QueryBuilders.fuzzyQuery("corpName","盒马先生").prefixLength(2));//----------------------------------------------------------request.source(builder);//3. 执行SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.3.5 wildcard查询
通配查询，和MySQL中的like是一个套路，可以在查询时，在字符串中指定通配符*和占位符？
# wildcard 查询POST /sms-logs-index/sms-logs-type/_search{"query": {"wildcard": {"corpName": {"value": "中国*" # 可以使用*和？指定通配符和占位符}}}}
代码实现方式
// Java代码实现Wildcard查询@Testpublic void findByWildCard() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//----------------------------------------------------------builder.query(QueryBuilders.wildcardQuery("corpName","中国*"));//----------------------------------------------------------request.source(builder);//3. 执行SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.3.6 range查询
范围查询，只针对数值类型，对某一个Field进行大于或者小于的范围指定
# range 查询POST /sms-logs-index/sms-logs-type/_search{"query": {"range": {"fee": {"gt": 5,"lte": 10# 可以使用 gt：>gte：>=lt：<lte：<=}}}}
代码实现方式
// Java实现range范围查询@Testpublic void findByRange() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//----------------------------------------------------------builder.query(QueryBuilders.rangeQuery("fee").lte(10).gte(5));//----------------------------------------------------------request.source(builder);//3. 执行SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.3.7 regexp查询
正则查询，通过你编写的正则表达式去匹配内容。
Ps：prefix，fuzzy，wildcard和regexp查询效率相对比较低，要求效率比较高时，避免去使用
# regexp 查询POST /sms-logs-index/sms-logs-type/_search{"query": {"regexp": {"mobile": "180[0-9]{8}" # 编写正则}}}
代码实现方式
// Java代码实现正则查询@Testpublic void findByRegexp() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();//----------------------------------------------------------builder.query(QueryBuilders.regexpQuery("mobile","139[0-9]{8}"));//----------------------------------------------------------request.source(builder);//3. 执行SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.4 深分页Scroll
ES对from + size是有限制的，from和size二者之和不能超过1W
原理：
from+size在ES查询数据的方式：
第一步现将用户指定的关键进行分词。第二步将词汇去分词库中进行检索，得到多个文档的id。第三步去各个分片中去拉取指定的数据。耗时较长。第四步将数据根据score进行排序。耗时较长。第五步根据from的值，将查询到的数据舍弃一部分。第六步返回结果。
scroll+size在ES查询数据的方式：
第一步现将用户指定的关键进行分词。第二步将词汇去分词库中进行检索，得到多个文档的id。第三步将文档的id存放在一个ES的上下文中。第四步根据你指定的size的个数去ES中检索指定个数的数据，拿完数据的文档id，会从上下文中移除。第五步如果需要下一页数据，直接去ES的上下文中，找后续内容。第六步循环第四步和第五步
Scroll查询方式，不适合做实时的查询
# 执行scroll查询，返回第一页数据，并且将文档id信息存放在ES上下文中，指定生存时间1mPOST /sms-logs-index/sms-logs-type/_search?scroll=1m{"query": {"match_all": {}},"size": 2,"sort": [# 排序{"fee": {"order": "desc"}}]}# 根据scroll查询下一页数据POST /_search/scroll{"scroll_id": "<根据第一步得到的scorll_id去指定>","scroll": "<scorll信息的生存时间>"}# 删除scroll在ES上下文中的数据DELETE /_search/scroll/scroll_id
代码实现方式
// Java实现scroll分页@Testpublic void scrollQuery() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定scroll信息request.scroll(TimeValue.timeValueMinutes(1L));//3. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();builder.size(4);builder.sort("fee", SortOrder.DESC);builder.query(QueryBuilders.matchAllQuery());request.source(builder);//4. 获取返回结果scrollId，sourceSearchResponse resp = client.search(request, RequestOptions.DEFAULT);String scrollId = resp.getScrollId();System.out.println("----------首页---------");for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}while(true) {//5. 循环 - 创建SearchScrollRequestSearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);//6. 指定scrollId的生存时间scrollRequest.scroll(TimeValue.timeValueMinutes(1L));//7. 执行查询获取返回结果SearchResponse scrollResp = client.scroll(scrollRequest, RequestOptions.DEFAULT);//8. 判断是否查询到了数据，输出SearchHit[] hits = scrollResp.getHits().getHits();if(hits != null && hits.length > 0) {System.out.println("----------下一页---------");for (SearchHit hit : hits) {System.out.println(hit.getSourceAsMap());}}else{//9. 判断没有查询到数据-退出循环System.out.println("----------结束---------");break;}}//10. 创建CLearScrollRequestClearScrollRequest clearScrollRequest = new ClearScrollRequest();//11. 指定ScrollIdclearScrollRequest.addScrollId(scrollId);//12. 删除ScrollIdClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);//13. 输出结果System.out.println("删除scroll：" + clearScrollResponse.isSucceeded());}
6.5 delete-by-query
根据term，match等查询方式去删除大量的文档
Ps：如果你需要删除的内容，是index下的大部分数据，推荐创建一个全新的index，将保留的文档内容，添加到全新的索引
# delete-by-queryPOST /sms-logs-index/sms-logs-type/_delete_by_query{"query": {"range": {"fee": {"lt": 4}}}}
代码实现方式
// Java代码实现@Testpublic void deleteByQuery() throws IOException {//1. 创建DeleteByQueryRequestDeleteByQueryRequest request = new DeleteByQueryRequest(index);request.types(type);//2. 指定检索的条件 和SearchRequest指定Query的方式不一样request.setQuery(QueryBuilders.rangeQuery("fee").lt(4));//3. 执行删除BulkByScrollResponse resp = client.deleteByQuery(request, RequestOptions.DEFAULT);//4. 输出返回结果System.out.println(resp.toString());}
6.6 复合查询
6.6.1 bool查询
复合过滤器，将你的多个查询条件，以一定的逻辑组合在一起。
must： 所有的条件，用must组合在一起，表示And的意思must_not：将must_not中的条件，全部都不能匹配，标识Not的意思should：所有的条件，用should组合在一起，表示Or的意思
# 查询省份为武汉或者北京# 运营商不是联通# smsContent中包含中国和平安# bool查询POST /sms-logs-index/sms-logs-type/_search{"query": {"bool": {"should": [{"term": {"province": {"value": "北京"}}},{"term": {"province": {"value": "武汉"}}}],"must_not": [{"term": {"operatorId": {"value": "2"}}}],"must": [{"match": {"smsContent": "中国"}},{"match": {"smsContent": "平安"}}]}}}
代码实现方式
// Java代码实现Bool查询@Testpublic void BoolQuery() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();// # 查询省份为武汉或者北京boolQuery.should(QueryBuilders.termQuery("province","武汉"));boolQuery.should(QueryBuilders.termQuery("province","北京"));// # 运营商不是联通boolQuery.mustNot(QueryBuilders.termQuery("operatorId",2));// # smsContent中包含中国和平安boolQuery.must(QueryBuilders.matchQuery("smsContent","中国"));boolQuery.must(QueryBuilders.matchQuery("smsContent","平安"));builder.query(boolQuery);request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.6.2 boosting查询
boosting查询可以帮助我们去影响查询后的score。
positive：只有匹配上positive的查询的内容，才会被放到返回的结果集中。negative：如果匹配上和positive并且也匹配上了negative，就可以降低这样的文档score。negative_boost：指定系数，必须小于1.0
关于查询时，分数是如何计算的：
搜索的关键字在文档中出现的频次越高，分数就越高指定的文档内容越短，分数就越高我们在搜索时，指定的关键字也会被分词，这个被分词的内容，被分词库匹配的个数越多，分数越高
# boosting查询 收货安装POST /sms-logs-index/sms-logs-type/_search{"query": {"boosting": {"positive": {"match": {"smsContent": "收货安装"}},"negative": {"match": {"smsContent": "王五"}},"negative_boost": 0.5}}}
代码实现方式
// Java实现Boosting查询@Testpublic void BoostingQuery() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件SearchSourceBuilder builder = new SearchSourceBuilder();BoostingQueryBuilder boostingQuery = QueryBuilders.boostingQuery(QueryBuilders.matchQuery("smsContent", "收货安装"),QueryBuilders.matchQuery("smsContent", "王五")).negativeBoost(0.5f);builder.query(boostingQuery);request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.7 filter查询
query，根据你的查询条件，去计算文档的匹配度得到一个分数，并且根据分数进行排序，不会做缓存的。
filter，根据你的查询条件去查询文档，不去计算分数，而且filter会对经常被过滤的数据进行缓存。
# filter查询POST /sms-logs-index/sms-logs-type/_search{"query": {"bool": {"filter": [{"term": {"corpName": "盒马鲜生"}},{"range": {"fee": {"lte": 4}}}]}}}
代码实现方式
// Java实现filter操作@Testpublic void filter() throws IOException {//1. SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 查询条件SearchSourceBuilder builder = new SearchSourceBuilder();BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();boolQuery.filter(QueryBuilders.termQuery("corpName","盒马鲜生"));boolQuery.filter(QueryBuilders.rangeQuery("fee").lte(5));builder.query(boolQuery);request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
6.8 高亮查询【重点】
高亮查询就是你用户输入的关键字，以一定的特殊样式展示给用户，让用户知道为什么这个结果被检索出来。
高亮展示的数据，本身就是文档中的一个Field，单独将Field以highlight的形式返回给你。
ES提供了一个highlight属性，和query同级别的。
fragment_size：指定高亮数据展示多少个字符回来。pre_tags：指定前缀标签，举个栗子< font color=“red” >post_tags：指定后缀标签，举个栗子< /font >fields：指定哪几个Field以高亮形式返回
RESTful实现
# highlight查询POST /sms-logs-index/sms-logs-type/_search{"query": {"match": {"smsContent": "盒马"}},"highlight": {"fields": {"smsContent": {}},"pre_tags": "<font color='red'>","post_tags": "</font>","fragment_size": 10}}
代码实现方式
// Java实现高亮查询@Testpublic void highLightQuery() throws IOException {//1. SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定查询条件（高亮）SearchSourceBuilder builder = new SearchSourceBuilder();//2.1 指定查询条件builder.query(QueryBuilders.matchQuery("smsContent","盒马"));//2.2 指定高亮HighlightBuilder highlightBuilder = new HighlightBuilder();highlightBuilder.field("smsContent",10).preTags("<font color='red'>").postTags("</font>");builder.highlighter(highlightBuilder);request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 获取高亮数据，输出for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getHighlightFields().get("smsContent"));}}
6.9 聚合查询【重点】
ES的聚合查询和MySQL的聚合查询类似，ES的聚合查询相比MySQL要强大的多，ES提供的统计数据的方式多种多样。
# ES聚合查询的RESTful语法POST /index/type/_search{"aggs": {"名字（agg）": {"agg_type": {"属性": "值"}}}}
6.9.1 去重计数查询
去重计数，即Cardinality，第一步先将返回的文档中的一个指定的field进行去重，统计一共有多少条
# 去重计数查询 北京 上海 武汉 山西POST /sms-logs-index/sms-logs-type/_search{"aggs": {"agg": {"cardinality": {"field": "province"}}}}
代码实现方式
// Java代码实现去重计数查询@Testpublic void cardinality() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定使用的聚合查询方式SearchSourceBuilder builder = new SearchSourceBuilder();builder.aggregation(AggregationBuilders.cardinality("agg").field("province"));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 获取返回结果Cardinality agg = resp.getAggregations().get("agg");long value = agg.getValue();System.out.println(value);}
6.9.2 范围统计
统计一定范围内出现的文档个数，比如，针对某一个Field的值在 0100,100200,200~300之间文档出现的个数分别是多少。
范围统计可以针对普通的数值，针对时间类型，针对ip类型都可以做相应的统计。
range，date_range，ip_range
数值统计
# 数值方式范围统计POST /sms-logs-index/sms-logs-type/_search{"aggs": {"agg": {"range": {"field": "fee","ranges": [{"to": 5},{"from": 5, # from有包含当前值的意思 "to": 10},{"from": 10}]}}}}
时间范围统计
# 时间方式范围统计POST /sms-logs-index/sms-logs-type/_search{"aggs": {"agg": {"date_range": {"field": "createDate","format": "yyyy", "ranges": [{"to": 2000},{"from": 2000}]}}}}
ip统计方式
# ip方式 范围统计POST /sms-logs-index/sms-logs-type/_search{"aggs": {"agg": {"ip_range": {"field": "ipAddr","ranges": [{"to": "10.126.2.9"},{"from": "10.126.2.9"}]}}}}
代码实现方式
// Java实现数值 范围统计@Testpublic void range() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定使用的聚合查询方式SearchSourceBuilder builder = new SearchSourceBuilder();//---------------------------------------------builder.aggregation(AggregationBuilders.range("agg").field("fee").addUnboundedTo(5).addRange(5,10).addUnboundedFrom(10));//---------------------------------------------request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 获取返回结果Range agg = resp.getAggregations().get("agg");for (Range.Bucket bucket : agg.getBuckets()) {String key = bucket.getKeyAsString();Object from = bucket.getFrom();Object to = bucket.getTo();long docCount = bucket.getDocCount();System.out.println(String.format("key：%s，from：%s，to：%s，docCount：%s",key,from,to,docCount));}}
6.9.3 统计聚合查询
他可以帮你查询指定Field的最大值，最小值，平均值，平方和等
使用：extended_stats
# 统计聚合查询POST /sms-logs-index/sms-logs-type/_search{"aggs": {"agg": {"extended_stats": {"field": "fee"}}}}
代码实现方式
// Java实现统计聚合查询@Testpublic void extendedStats() throws IOException {//1. 创建SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定使用的聚合查询方式SearchSourceBuilder builder = new SearchSourceBuilder();//---------------------------------------------builder.aggregation(AggregationBuilders.extendedStats("agg").field("fee"));//---------------------------------------------request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 获取返回结果ExtendedStats agg = resp.getAggregations().get("agg");double max = agg.getMax();double min = agg.getMin();System.out.println("fee的最大值为：" + max + "，最小值为：" + min);}
其他的聚合查询方式查看官方文档：https://www.elastic.co/guide/en/elasticsearch/reference/6.5/index.html
6.10 地图经纬度搜索
ES中提供了一个数据类型 geo_point，这个类型就是用来存储经纬度的。
创建一个带geo_point类型的索引，并添加测试数据
# 创建一个索引，指定一个name，locaitonPUT /map{"settings": {"number_of_shards": 5,"number_of_replicas": 1},"mappings": {"map": {"properties": {"name": {"type": "text"},"location": {"type": "geo_point"}}}}}# 添加测试数据PUT /map/map/1{"name": "天安门","location": {"lon": 116.403981,"lat": 39.914492 }}PUT /map/map/2{"name": "海淀公园","location": {"lon": 116.302509,"lat": 39.991152 }}PUT /map/map/3{"name": "北京动物园","location": {"lon": 116.343184,"lat": 39.947468 }}
6.10.1 ES的地图检索方式
6.10.2 基于RESTful实现地图检索
geo_distance
# geo_distancePOST /map/map/_search{"query": {"geo_distance": {"location": {# 确定一个点"lon": 116.433733,"lat": 39.908404},"distance": 3000, # 确定半径"distance_type": "arc"# 指定形状为圆形}}}
geo_bounding_box
# geo_bounding_boxPOST /map/map/_search{"query": {"geo_bounding_box": {"location": {"top_left": {# 左上角的坐标点"lon": 116.326943,"lat": 39.95499},"bottom_right": {# 右下角的坐标点"lon": 116.433446,"lat": 39.908737}}}}}
geo_polygon
# geo_polygonPOST /map/map/_search{"query": {"geo_polygon": {"location": {"points": [# 指定多个点确定一个多边形{"lon": 116.298916,"lat": 39.99878},{"lon": 116.29561,"lat": 39.972576},{"lon": 116.327661,"lat": 39.984739}]}}}}
6.10.3 Java实现geo_polygon
// 基于Java实现geo_polygon查询@Testpublic void geoPolygon() throws IOException {//1. SearchRequestSearchRequest request = new SearchRequest(index);request.types(type);//2. 指定检索方式SearchSourceBuilder builder = new SearchSourceBuilder();List<GeoPoint> points = new ArrayList<>();points.add(new GeoPoint(39.99878,116.298916));points.add(new GeoPoint(39.972576,116.29561));points.add(new GeoPoint(39.984739,116.327661));builder.query(QueryBuilders.geoPolygonQuery("location",points));request.source(builder);//3. 执行查询SearchResponse resp = client.search(request, RequestOptions.DEFAULT);//4. 输出结果for (SearchHit hit : resp.getHits().getHits()) {System.out.println(hit.getSourceAsMap());}}
