Elasticsearch的初步学习

最新推荐文章于 2024-07-20 14:30:41 发布

愤怒的阿斗

最新推荐文章于 2024-07-20 14:30:41 发布

阅读量606

点赞数 11

分类专栏： Elasticsearch 新的学习搜索引擎文章标签：搜索引擎 elasticsearch

本文链接：https://blog.csdn.net/qq_35676686/article/details/140203747

版权

新的学习同时被 3 个专栏收录

12 篇文章 0 订阅

订阅专栏

Elasticsearch

1 篇文章 0 订阅

订阅专栏

搜索引擎

1 篇文章 0 订阅

订阅专栏

JAVA搜索引擎的学习

概念

1.文档和词条

文档：每一条数据就是一个文档。
词条：对文档中的内容分词，得到的词就是词条。

2.正向索引

基于文档Id创建索引，查找词条时必须先找到文档，再判断是否包含该词条。

3.倒排索引

对于文档内容分词，对分词词条创建索引，并记录词条所在的文档信息，查询时现根据词条查询文档id，而后获取到文档。

4.索引

索引：相同类型的文档的集合。
映射：索引中文档的字段约束信息，类似表的结构约束。

引擎介绍

Elasticsearch引擎介绍

一个开源的分布式搜索引擎，可以用来实现搜索、日志统计、分析、系统监控等功能。
是一个非常强大的开源搜索引擎，可以帮助我们从海量的数据中快速搜索出想要的数据。
Elasticsearch结合Kibina、Logstash、Beats，也就是elastic stack。(ELK是三款软件的简称，分别是Elasticsearch、Logstash、Kibana，在发展的过程中，又有新成员Beats的加入，所以就形成了Elastic Stack。说白了Elastic Stack相当于以前的ELK。)被广泛应用在日志分析、实时监控等领域。
Elasticsearch底层是基于Lucene来实现的。（Lucene是一个Java语言的搜索引擎类库。Lucene的优势是易拓展，高性能（基于倒排索引）。缺点是只限于JAVA语言开发，学习曲线陡峭，不支持水平拓展。）Elasticsearch相较于Lucene，Elasticsearch支持分布式，可水平拓展，提供Restful接口，可被任何语言调用。

工作原理

1.索引数据

	在能够进行搜索之前，数据先要通过索引存储到ES中，这个过程涉及到数据结构的优化以便于高效检索。索引会把数据转换成一个倒排索引结构。倒排索引是一种特殊的索引类型，它列出了每个唯一词项，以及它们在文档集合中出现的所有位置。这就是为什么ES在文本搜索非常快的原因。

2.分布式架构

	Elasticsearch将数据分散存储在不同的节点上，称为分片。这些分片可以在集群中的不同服务器之间进行复制和分配，提高系统的可用性和伸缩性。在进行查询时，查询指令会并行发送到所有的相关分片。这意味着ES能够快速检索大数据集，因为工作是分布式并行完成的。

3.搜索操作

	当ES接收到用户的查询请求时，它首先解析查询，将其转化为可以在倒排索引上执行的低级操作。查询可以很复杂，不仅仅是对特定词项的匹配，还可以包含过滤器（filters）、聚合（aggregations）和排序（sorts）等操作。查询执行过程中会对多个分片并发检索数据，然后将结果合并，最终以统一的格式返回给用户。

4.相关性评分和排序

	ES进行全文搜索时会对返回的结果进行相关性评分，这称为评分过程（scoring process），默认使用一种名为TF-IDF的算法，虽然现在常用更先进的算法如BM25。搜索结果根据相关性评分（和可能的其他排序标准）排序后返回给用户。

5.缓存与优化

	ES会使用缓存来优化重复查询的速度，对常见的查询结果、过滤器和聚合进行缓存。还可根据查询模式进行优化，例如预加载数据到内存中，提前计算一些聚合数据等。

6.实时性和准实时性

	ES支持近实时搜索，这意味着从文档被索引到它们可被搜索只有轻微延迟。通过使用事务日志和定期刷新机制来保证数据的可查询性。

应用场景

全文搜索： Elasticsearch 提供了全文搜索的功能，适用于电商商品搜索、App 搜索、企业内部信息搜索、IT 系统搜索等。例如我们可以为每一个商品作为文档保存进 Elasticsearch，然后使用 Elasticsearch 的查询语言来对文档进行分词匹配、相关性评分、高亮显示等操作，返回相关度高的结果列表。
日志分析： Elasticsearch 可以用来收集、存储和分析海量的日志数据，如项目日志、Nginx log、MySQL Log 等，往往很难从繁杂的日志中获取有价值的信息。Elasticsearch 能够借助 Beats、Logstash 等工具快速对接各种常见的数据源，并通过集成的 Kibana 高效地完成日志的可视化分析，让日志产生价值。
运维监控： Elasticsearch 也可以用来监控和管理 IT 系统的运行状态和性能指标，如 CPU、内存、磁盘、网络等。可以使用 Beats、Logstash 将这些数据实时采集并索引到 Elasticsearch 中，然后通过 Kibana 构建自定义的仪表盘和告警规则，实现实时的运维监控和预警。
数据可视化： Elasticsearch 与 Kibana 的结合提供了强大的数据可视化能力，可以使用 Kibana 来创建各种类型的图表和仪表盘，展示 Elasticsearch 中存储或聚合的数据，如直方图、饼图、地图、时间线等。还可以使用 Kibana 的 Canvas 功能来制作动态的数据展示页面，或者使用 Kibana 的 Lens 功能来进行交互式的数据探索。

Elasticsearch常用数据类型

binary类型： 二进制类型 ,值以base64字符串的形式存贮,_source默认不会存贮该类型的值，如果需要实际的存贮，请设置 store属性为true默认是false
Bool类型： 布尔类型，True或False
Keyword类型： 关键字类型，该字段适合聚合和排序的使用，在es分词中当做一个整体，如果涉及term精确查询，也可以进行考虑。
widecard类型： 适合通配符类型和正则表达式类型搜索，而text类型不支持通配符的搜索
数字类型： short,interger,long unsigned_long,
Dates类型： 日期类型包含Date ,Date_nanos
alais类型： 为已存在的字段定义别名，别名可用于却大多数搜索api和field capabilities
object类型： 该类型值为一个json类型
text类型： 该类型为全文搜索类型，常与match系列进行匹配
Arrays类型： 在ES中没有专门的数组类型，所有类型字段都可以有一个或多个的值
nested类型： 子文档就存在父文档某个字段内部,适合子文档数量较少的情况。（一个文档最多有50个nested字段，所有的nested类型的字段存储最大数量是10000条）

// 创建索引时，设置索引属性的数据类型样例
PUT _index
{
    "mapping":{ 
        "type_name":{  								// _type名称
            "properties": {
                "binary_name":{ 					// 设置为binary类型字段
                    "type":"binary",
                     "store": true 					// 默认为False,如果需要在source显示 则设置为True
                },
                 "boolean_name":{ 					// 设置为boolean类型字段
                     "type": "boolean" 
                },
                "keyword_name":{ 					// 设置为keyword类型字段
                    "type":"keyword"
                },
                "constant_keyword_name":{
                    "type": "constant_keyword", 	// 设置该类型表示所有文档该字段值都是一样的
                    "value":"constant"
                },
                "wildcard_name": {					// 设置为wildcard类型字段
                    "type": "wildcard"
                },
                "integer_name": {					// 设置为integer类型字段
                    "type": "integer"
                },
                "float_name": {						// 设置为float类型字段
                    "type": "float"
                },
                "date_name":{						// 设置为date类型字段
                    "type": "date",
                    "format":"yyyy-MM-dd HH:mm:ss"	// 设置指定格式化类型，如果不设置则默认类型为yyyy-MM-dd ‘T’ HH:mm:ss.SSSZ
                },
                "text_name":{						// 设置为text_name类型字段
                    "type":"text"
                },
                "nested_name":{ 					// 设置为nested类型字段
                    "type": "nested",
                    "properties": {
                        "names":{
                            "type":"text"
                        },
                        "alias_name":{ 				// 设置为alias类型字段别名
                            "type": "alias",
                            "path":"nested_name.names"
                        }
                    }  
                }
            }
        }
    }
}

Elasticsearch查询

在这里插入图片描述

ES的基础查询示例与Java实现

keyword: 表示该字段是一个keyword类型的字段。Keyword类型的字段会将文本作为一个整体进行索引和搜索，不会进行分词。如果字段名后面不加"keyword"，该字段会被当作text类型的字段。Text类型的字段会进行分词，将文本拆分成一个个词项进行索引和搜索。

1.等值查询term

ES查询

GET /person/_search
{
	"query":{
		"term":{
			"name.keyword":{
				"value":"张三",
				"boost":1.0
			}
		}
	}
}
// 关闭评分的查询（打分是会耗费性能的，如果没有需要的可以关闭评分）
{
	"query":{
		"constant_score":{
			"filter":{
				"term":{
					"name.keyword":{
						"value":"张三",
						"boost":1.0
					}
				}
			}
		}
		"boost":1.0
	}
}

ES查询的结果

{
	"took":0,
	"timed_out":false,
	"_shards":{			// 分片信息
		"total":1,		// 总计分片数
		"successful":1,	// 查询成功的分片数
		"skipped":0,	// 跳过查询的分片数
		"failed":0,		// 查询失败的分片数
	},
	"hits":{					// 命中结果
		"total":{				
			"value":1,			// 数量
			"relation":"eq"		// 等于
		},
		"max_score": 1.123456,	// 最高分数
		"hits":[
			{
				"_index":"",	// 索引
				"_type":"",		// 类型
				"_id":"",
				"_score":"",	// 分数
				"_source":{
					"name":"张三",
					"sex":"男",
					"age":30,
					"id":1
				}
			}
		]
	}
}

JAVA代码

@Resource
private RestHighLevelClient client;

public void queryTerm(){
	// 根据索引创建查询请求
	SearchRequest searchRequest = new SearchRequest("indexes");
	// 指定只能在哪些文档库中查询，可添加多个且没有上限
	searchRequest.indices("library1","library2","library3");
	SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
	// 查询语句
	searchSourceBuilder.query(QueryBuilders.termQuery("name.keyword","张三"));
	// 设置查询的起始索引位置，从第一条开始
	searchSourceBuilder.from(0);
	// 设置查询的返回数量，共返回5条文档数据
	searchSourceBuilder.size(5);
	System.out.println("searchSourceBuilder=",JSON.toJSONString(searchSourceBuilder));
	// 将SearchSourceBuilder对象添加到搜索请求中
	searchRequest.source(searchSourceBuilder);
	// 返回结果
	SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
	System.out.println("SearchResponse={}",JSON.toJSONString(searchResponse));

	/* 关闭评分的查询 */ 
	SearchSourceBuilder searchSourceBuilder1 = new SearchSourceBuilder();
	searchSourceBuilder1.query(QueryBuilders.constantScoreQuery(QueryBuilders.termQuery("name.keyword","张三")));
	searchRequest.source(searchSourceBuilder1);
	SearchResponse searchResponse1 = client.search(searchRequest,RequestOptions.DEFAULT);
}

2.多值查询terms

ES查询

GET /person/_search
{
	"query":{
		"terms":{
			"name.keyword":[
				"张三",
				"李四"
			],
			"boost":1.0
		}
	}
}

JAVA代码

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.termsQuery("name.keyword",Arrays.asList("张三","李四")));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

3.范围查询range

ES查询

GET /person/_search
{
	"query":{
		"range":{
			"age":{
				"from":10,
				"to":18,
				"include_lower":true,
				"include_upper":true,
				"boost":1.0
			}
		}
	}
}

JAVA代码

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.rangeQuery("age").gte(10).lte(18));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

4.前缀查询prefix

ES查询

GET /person/_search
{
	"query":{
		"prefix":{
			"name.keyword":{
				"value":"张",
				"boost":1.0
			}
		}
	}
}

JAVA代码

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.prefixQuery("name.keyword","张"));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

5.通配符查询wildcard

"?“为1个任意字符，”*"为匹配零个或多个字符

ES查询

GET /person/_search
{
	"query":{
		"wildcard":{
			"name.keyword":{
				"wildcard":"张*丰",	// 可以匹配张丰，也可以是张三丰，张三三丰
				"boost":1.0
			}
		}
	}
}
// 或
GET _index/_type/_search
{
	"query":{
		"wildcard":{
				"name":"王小?", //可以匹配王小小，如果值为 ： "王?" 则无法匹配：王小小
				//"name":"王*", //可以匹配：王小，也可以匹配：王小小
				//"name":"*王*" //可以匹配：洲王小，也可以匹配：洲洲洲王小
			}
		}
}

JAVA代码

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.wildcardQuery("name.keyword","张*丰"));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

6.多条件查询

ES查询

GET /person/_search
{
	"query":{
		"bool":{
			"must":[
				{
					"term":{
						"name.keyword":{
							"value":"张三",
							"boost":1.0
						}
					}
				},
				{
					"term":{
						"age":{
							"value":18,
							"boost":1.0
						}
					}
				}
			],
			"adjust_pure_negative":true,	// 默认为true，排除关键词完全不匹配的结果
			"boost":1.0
		}
	}
}

JAVA代码

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.boolQuery()
						.must(QueryBuilders.termQuery("name.keyword","张三"))
						.must(QueryBuilders.termQuery("age",18)));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

7.bool过滤器

must: 所有的语句都必须匹配，与’='等价。
must_not: 所有的语句都不能匹配，与’!='或’not in’等价。
should: 至少有多个语句需要匹配，数量由参数控制。当没有must语句的时候，至少有一个should语句必须匹配。
filter: 通过不计算相关性分数并利用缓存来获得更好的性能，从而提高查询效率。‌
ES查询

GET /person/_search
{
	"query":{
		"bool":{
			"must":[
				{
					"term":{
						"name.keyword":{
							"value":"张三",
							"boost":1.0
						}
					}
				}
			],
			"should":[
				{
					"term":{
						"address.keyword":{
							"value":"武汉",
							"boost":1.0
						}
					}
				},
				{
					"term":{
						"school.keyword":{
							"value":"武汉大学",
							"boost":1.0
						}
					}
				}
			],
			"adjust_pure_negative":true,	// 默认为true，排除关键词完全不匹配的结果
			"minimum_should_match":"1",		//控制需要匹配的should语句数量，可以是一个绝对数字也可以是百分比
			"boost":1.0
		}
	}
}

JAVA代码

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.boolQuery()
						.must(QueryBuilders.termQuery("name.keyword","张三"))
						.should(QueryBuilders.termQuery("address.keyword","武汉"))
						.should(QueryBuilders.termQuery("school.keyword","武汉大学"))
						.minimumShouldMatch(1));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

8.Filter查询

query和filter的区别：query查询的时候，会先比较查询条件，然后计算分值，最后返回文档结果；而filter是先判断是否满足查询条件，如果不满足会缓存查询结果（记录该文档不满足结果），满足的话，就直接缓存结果，filter不会对结果进行评分，能够提高查询效率。

filter单独使用

{
	"query":{
		"bool":{
			"filter":[
				{
					"term":{
						"name.keyword":{
							"value":"张三",
							"boost":1.0
						}
					}
				}
			],
			"adjust_pure_negative":true,
			"boost":1.0
		}
	}
}

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.boolQuery()
						.filter(QueryBuilders.termQuery("name.keyword","张三")));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

和must、must_not同级

{
	"query":{
		"bool":{
			"must":[
				{
					"term":{
						"address.keyword":{
							"value":"武汉",
							"boost":1.0
						}
					}
				}
			],
			"filter":[
				{
					"term":{
						"name.keyword":{
							"value":"张三",
							"boost":1.0
						}
					}
				}
			],
			"adjust_pure_negative":true,
			"boost":1.0
		}
	}
}

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.boolQuery()
						.must(QueryBuilders.termQuery("address.keyword","武汉"))
						.filter(QueryBuilders.termQuery("name.keyword","张三")));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

将must、must_not置于filter下

{
	"query":{
		"bool":{
			"filter":[
				{
					"bool":{
						"must":[
							{
								"term":{
									"name.keyword":{
										"value":"张三",
										"boost":1.0
									}
								}
							},
							{
								"term":{
									"address.keyword":{
										"value":"武汉",
										"boost":1.0
									}
								}
							},
						],
						"must_not":[
							{
								"term":{
									"school.keyword":{
										"value":"武汉大学",
										"boost":1.0
									}
								}
							},
						],
						"adjust_pure_negative":true,
						"boost":1.0
					}
				}
			],
			"adjust_pure_negative":true,
			"boost":1.0
		}
	}
}

SearchRequest searchRequest = new SearchRequest("indexes");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.boolQuery()
						.filter(QueryBuilders.boolQuery()
								.must(QueryBuilders.termQuery("name.keyword","张三"))
								.must(QueryBuilders.termQuery("address.keyword","武汉"))
								.mustNot(QueryBuilders.termQuery("school.keyword","武汉大学")));
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);

9.聚合查询

最值、平均值、求和

ES查询

GET /person/_search
{
	"aggregations":{
		"max_age":{
			"max":{
				"field":"age"
			}
		}
	},
	"size":20			// 结果默认返回10条文档数据，可以自主控制返回数据条数
}

JAVA代码

@Resource
private RestHighLevelClient client;

public void maxQueryTerm(){
	SearchRequest searchRequest = new SearchRequest("indexes");
	SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
	// 聚合查询条件
	AggregationBuilder aggregationBuilder = AggregationBuilders.max("max_age").field("age");
	// 其它统计查询
	//AggregationBuilder minBuilder = AggregationBuilders.min("min_age").field("age");
	//AggregationBuilder avgBuilder = AggregationBuilders.avg("avg_age").field("age");
	//AggregationBuilder sumBuilder = AggregationBuilders.sum("sum_age").field("age");
	//AggregationBuilder countBuilder = AggregationBuilders.count("count_age").field("age");
	searchSourceBuilder.aggregation(aggregationBuilder);
	// 设置返回的数据条数
	searchSourceBuilder.size(20);

	searchRequest.source(searchSourceBuilder);
	SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
}

去重查询

ES查询

GET /person/_search
{
	"aggregations":{
		"name_count":{
			"cardinality":{
				"field":"name.keyword"
			}
		}
	}
}

JAVA代码

@Resource
private RestHighLevelClient client;

public void maxQueryTerm(){
	SearchRequest searchRequest = new SearchRequest("indexes");
	SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
	// 聚合查询条件
	AggregationBuilder aggregationBuilder = AggregationBuilders.cardinality("name_count").field("name.keyword");
	// 设置返回的数据条数
	searchSourceBuilder.size(0);
	searchSourceBuilder.aggregation(aggregationBuilder);
	searchRequest.source(searchSourceBuilder);
	// 执行查询
	SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
}

分组聚合

ES查询

GET /person/_search
// 单条件分组
{
	"aggregations":{
		"name_count":{
			"terms":{
				"feild":"name.keyword",
				"size":5,
				"min_doc_count":1,
				"shard_min_doc_count":0,
				"show_term_doc_count_error":false,
				"order":[
					{"_count":"desc"},
					{"_key":"asc"}
				]
			}
		}
	},
	"size":0
}

// 多条件分组
GET /person/_search
{
	"aggregations":{
		"name_count":{
			"terms":{
				"feild":"name.keyword",
				"size":5
			},
			"aggregations":{
				"address_count":{
					"terms":{
						"feild":"address.keyword",
						"size":5
					}
				}
			}
		}
	}
}

JAVA代码

@Resource
private RestHighLevelClient client;

public void countQueryTerm(){
	SearchRequest searchRequest = new SearchRequest("indexes");
	SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
	// 设置返回的数据条数
	searchSourceBuilder.size(0);
	// 聚合查询条件
	AggregationBuilder aggregationBuilder = AggregationBuilders.terms("name_count").field("name.keyword");
	searchSourceBuilder.aggregation(aggregationBuilder);
	searchRequest.source(searchSourceBuilder);
	// 执行查询
	SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
}

过滤聚合

ES查询

GET /person/_search
{
	"query":{
		"term":{
			"name.keyword":{
				"value":"张三",
				"boost":1.0
			}
		}
	},
	"aggregations":{
		"address_count":{
			"cardinality":{
				"feild":"address.keyword"
			}
		}
	}
}

JAVA代码

@Resource
private RestHighLevelClient client;

public void countQueryTerm(){
	SearchRequest searchRequest = new SearchRequest("indexes");
	SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
	// 聚合查询条件
	AggregationBuilder aggregationBuilder = AggregationBuilders.cardinality("address_count").field("address.keyword");
	searchSourceBuilder.aggregation(aggregationBuilder);
	searchSourceBuilder.query(QueryBuilders.termQuery("name.keyword","张三"));
	searchRequest.source(searchSourceBuilder);
	// 执行查询
	SearchResponse searchResponse = client.search(searchRequest,RequestOptions.DEFAULT);
}

10.单字段match

match为单字段查询，不能进行多字段组合查询

// 结构化写法
GET _index/type_search
{
	"query":{
		"match":{
			"name":"xw 是好人" 			// 根据es默认分词器，则为:['xw','是','好','人'],只要匹配任何一个则会进行返回
		}
	}
}
// 或
GET _index/type_search
{
	"query":{
		"match":{
			"name":{ 					// ES的Fieled值
				"query":"xw ,是好人" 	// 根据es默认分词器，则为:['xw','是','好','人']
				//"operator":"or",  		// 默认为or，只需要匹配其中一个关键词就可
				//"operator": "and" 		// 要匹配所有关键词
			}
		}
	}
}

11.查询全部match_all

GET _index/_type/_search
{
	"query":{
		"match_all":{
		
		}
	}
}

12.短语查询match_phrase

match_phrase为短语查询，对应的都要进行匹配，相对于match的"operator":“and”。类似mysql的 like ‘%<值>%’

GET _index/_type/_search
{
	"query":{
		"match_phrase":{
			"name":"张三 李四" 
		}
	}
}
// 或 
GET _index/_type/_search
{
	"query":{
		"match_phrase":{
			"name":{
				"query": "张三 李四",
				//"slop":0  			// slop参数默认为0，slop参数为两组词之间的最大可移动的间隔和顺序，在搜索的时候更加灵活
			}
		}
	}
}

13.前缀查询match_phrase_prefix

match_phrase_prefix 是最左前缀匹配,类似match_phrase ,差异点是根据分词器进行前缀匹配
match_phrase_prefix类似mysql的 like ‘<值>%’ 语法

GET _index/_type/_search
{
	"query":{
		"match_phrase_prefix":{
			"name": "张三 李四",  // 根据分词器然后进行最左前缀匹配，如果是"name":"张三 李四" 则match_phrase_prefix可以匹配，但是在match_phracse无法匹配
			//"max_expansions":5 // 前缀查询对性能影响很大，所以在使用的时候会对结果集进行限制，默认不进行限制
		}
	}
}

14.多字段查询multi_match

GET _index/_type/_search
{
	"query":{
		"multi_match":{
			"query":"武汉",
			"fields":["school","address"],
			"type":"" 		// phrase（实现match_phrase的方法），phrase_prefix（实现match_phrase_prefixd的方法）
		}
	}
}

Elasticsearch操作

Elasticsearch指令样例

1.获取mapping结构

GET _index/_type/_mapping

2.创建文档

PUT _index/_type/1
{
	"name": "xw",
	"age":18
}
或
POST _index/_type/1
{
	"name": "xw",
	"age":18
}

3.查询指定的索引信息

GET _index

4.查询指定文档的信息

GET _index/_type/1

5.查询指定条件（非结构化）

GET _index/_type/_search?q=name:xuw    #q:代表query,name:代表文档的对应的列字段，xuw:值

6.查询对应索引下所有的文档数据

GET _index/_type/_search
或
GET _index/_type/_search
"query":{
	"match_all":{
	}
}

7.删除指定的文档

DELETE _index/_type/1  #删除指定索引下的文档的第一条数据
DELETE _index/_type/2  #删除指定索引下的文档的第二条数据

8.删除指定的索引

DELETE _index

代码实战用例

1.创建索引

PUT /indexes1			// 索引名称
{
	"settings":{
		"index":{
			"number_of_shards":1,		// 分片数量
			"number_of_replicas":1		// 指定每个分片的副本数量，不小于1，保障基本的可用性和故障转移的能力
		}
	},
	"mappings":{
		"properties":{
			"title":{			// 索引属性1名称
				"type":"text",				// 数据类型
				"analyzer":"ik_max_word"	// 分词方式，将文本最大程度地拆分成独立的词汇
			},
			"content":{			// 索引属性2名称
				"type":"text",
				"analyzer":"ik_max_word"	// 分词方式有两种，ik-smart / ik-max-word
			}
		}
	}
}

2.添加数据

	POST /books/_doc/1
    {
        "title": "格林童话",
        "content": "这本书介绍了很多童话故事，有白雪公主、狮子王、美人鱼等。"
    }

    POST /books/_doc/2
    {
        "title": "中国童话故事",
        "content": "这本书介绍了很多中国童话故事。"
    }

3.查询

 	GET /books/_search
    {
        "query":{
            "match":{
                "title": "童话"
            }
        }
    }

4.查询的返回结果

    {
        "took": 0,
        "timed_out": false,
        "_shards": {
            "total": 1,
            "successful": 1,
            "skipped": 0,
            "failed": 0
        },
        "hits": {
            "total": {
                "value": 2,
                "relation": "eq"
            },
            "max_score": 0.11190013,
            "hits": [
                {
                    "_index": "books",
                    "_type": "_doc",
                    "_id": "1",
                    "_score": 0.11190013,
                    "_source": {
                        "title": "格林童话",
                        "content": "这本书介绍了很多童话故事，有白雪公主、狮子王、美人鱼等。"
                    }
                },
                {
                    "_index": "books",
                    "_type": "_doc",
                    "_id": "2",
                    "_score": 0.099543065,
                    "_source": {
                        "title": "中国童话故事",
                        "content": "这本书介绍了很多中国童话故事。"
                    }
                }
            ]
        }
    }