Java連接配接ES
建立Maven工程
導入依賴
<dependencies>
<!-- 1. elasticsearch-->
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>6.5.4</version>
</dependency>
<!-- 2. elasticsearch的進階API-->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>6.5.4</version>
</dependency>
<!-- 3. junit-->
<dependency>
<groupId>junit</groupId>
<artifactId>junit</artifactId>
<version>4.12</version>
</dependency>
<!-- 4. lombok-->
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
<version>1.16.22</version>
</dependency>
</dependencies>
建立測試類，連接配接ES
public class ESClient {
public static RestHighLevelClient getClient(){
// 建立HttpHost對象
HttpHost httpHost = new HttpHost("192.168.199.109",9200);
// 建立RestClientBuilder
RestClientBuilder clientBuilder = RestClient.builder(httpHost);
// 建立RestHighLevelClient
RestHighLevelClient client = new RestHighLevelClient(clientBuilder);
// 傳回
return client;
}
}
Java操作索引
建立索引
代碼如下
public class Demo2 {
RestHighLevelClient client = ESClient.getClient();
String index = "person";
String type = "man";
@Test
public void createIndex() throws IOException {
//1. 準備關于索引的settings
Settings.Builder settings = Settings.builder()
.put("number_of_shards", 3)
.put("number_of_replicas", 1);
//2. 準備關于索引的結構mappings
XContentBuilder mappings = JsonXContent.contentBuilder()
.startObject()
.startObject("properties")
.startObject("name")
.field("type","text")
.endObject()
.startObject("age")
.field("type","integer")
.endObject()
.startObject("birthday")
.field("type","date")
.field("format","yyyy-MM-dd")
.endObject()
.endObject()
.endObject();
//3. 将settings和mappings封裝到一個Request對象
CreateIndexRequest request = new CreateIndexRequest(index)
.settings(settings)
.mapping(type,mappings);
//4. 通過client對象去連接配接ES并執行建立索引
CreateIndexResponse resp = client.indices().create(request, RequestOptions.DEFAULT);
//5. 輸出
System.out.println("resp:" + resp.toString());
}
}
檢查索引是否存在
代碼如下
@Test
public void exists() throws IOException {
//1. 準備request對象
GetIndexRequest request = new GetIndexRequest();
request.indices(index);
//2. 通過client去操作
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
//3. 輸出
System.out.println(exists);
}
删除索引
代碼如下
@Test
public void delete() throws IOException {
//1. 準備request對象
DeleteIndexRequest request = new DeleteIndexRequest();
request.indices(index);
//2. 通過client對象執行
AcknowledgedResponse delete = client.indices().delete(request, RequestOptions.DEFAULT);
//3. 擷取傳回結果
System.out.println(delete.isAcknowledged());
}
Java操作文檔
添加文檔操作
代碼如下
public class Demo3 {
ObjectMapper mapper = new ObjectMapper();
RestHighLevelClient client = ESClient.getClient();
String index = "person";
String type = "man";
@Test
public void createDoc() throws IOException {
//1. 準備一個json資料
Person person = new Person(1,"張三",23,new Date());
String json = mapper.writeValueAsString(person);
//2. 準備一個request對象（手動指定id）
IndexRequest request = new IndexRequest(index,type,person.getId().toString());
request.source(json, XContentType.JSON);
//3. 通過client對象執行添加
IndexResponse resp = client.index(request, RequestOptions.DEFAULT);
//4. 輸出傳回結果
System.out.println(resp.getResult().toString());
}
}
修改文檔
代碼如下
@Test
public void updateDoc() throws IOException {
//1. 建立一個Map，指定需要修改的内容
Map<String,Object> doc = new HashMap<>();
doc.put("name","張大三");
String docId = "1";
//2. 建立request對象，封裝資料
UpdateRequest request = new UpdateRequest(index,type,docId);
request.doc(doc);
//3. 通過client對象執行
UpdateResponse update = client.update(request, RequestOptions.DEFAULT);
//4. 輸出傳回結果
System.out.println(update.getResult().toString());
}
删除文檔
代碼如下
@Test
public void deleteDoc() throws IOException {
//1. 封裝Request對象
DeleteRequest request = new DeleteRequest(index,type,"1");
//2. client執行
DeleteResponse resp = client.delete(request, RequestOptions.DEFAULT);
//3. 輸出結果
System.out.println(resp.getResult().toString());
}
Java批量操作文檔
批量添加
代碼如下
@Test
public void bulkCreateDoc() throws IOException {
//1. 準備多個json資料
Person p1 = new Person(1,"張三",23,new Date());
Person p2 = new Person(2,"李四",24,new Date());
Person p3 = new Person(3,"王五",25,new Date());
String json1 = mapper.writeValueAsString(p1);
String json2 = mapper.writeValueAsString(p2);
String json3 = mapper.writeValueAsString(p3);
//2. 建立Request，将準備好的資料封裝進去
BulkRequest request = new BulkRequest();
request.add(new IndexRequest(index,type,p1.getId().toString()).source(json1,XContentType.JSON));
request.add(new IndexRequest(index,type,p2.getId().toString()).source(json2,XContentType.JSON));
request.add(new IndexRequest(index,type,p3.getId().toString()).source(json3,XContentType.JSON));
//3. 用client執行
BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);
//4. 輸出結果
System.out.println(resp.toString());
}
批量删除
代碼如下
@Test
public 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"));
//2. client執行
BulkResponse resp = client.bulk(request, RequestOptions.DEFAULT);
//3. 輸出
System.out.println(resp);
}
ElasticSearch的各種查詢
term&terms查詢
term查詢
term的查詢是代表完全比對，搜尋之前不會對你搜尋的關鍵字進行分詞，對你的關鍵字去文檔分詞庫中去比對内容。
# term查詢
POST /sms-logs-index/sms-logs-type/_search
{
"from": 0, # limit ？
"size": 5, # limit x,?
"query": {
"term": {
"province": {
"value": "北京"
}
}
}
}
代碼實作方式
// Java代碼實作方式
@Test
public 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);
}
}
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實作
@Test
public void termsQuery() throws IOException {
//1. 建立request
SearchRequest 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. 輸出_source
for (SearchHit hit : resp.getHits().getHits()) {
System.out.println(hit.getSourceAsMap());
}
}
match查詢
match查詢屬于高層查詢，他會根據你查詢的字段類型不一樣，采用不同的查詢方式。match查詢，實際底層就是多個term查詢，将多個term查詢的結果給你封裝到了一起。
- 查詢的是日期或者是數值的話，他會将你基于的字元串查詢内容轉換為日期或者數值對待。
- 如果查詢的内容是一個不能被分詞的内容（keyword），match查詢不會對你指定的查詢關鍵字進行分詞。
- 如果查詢的内容時一個可以被分詞的内容（text），match會将你指定的查詢内容根據一定的方式去分詞，去分詞庫中比對指定的内容。
match_all查詢
查詢全部内容，不指定任何查詢條件。
# match_all查詢
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"match_all": {}
}
}
代碼實作方式
// java代碼實作
@Test
public void matchAllQuery() throws IOException {
//1. 建立Request
SearchRequest request = new SearchRequest(index);
request.types(type);
//2. 指定查詢條件
SearchSourceBuilder builder = new SearchSourceBuilder();
builder.query(QueryBuilders.matchAllQuery());
builder.size(20); // ES預設隻查詢10條資料，如果想查詢更多，添加size
request.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);
}
match查詢
指定一個Field作為篩選的條件
# match查詢
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"match": {
"smsContent": "收貨安裝"
}
}
}
代碼實作方式
@Test
public void matchQuery() throws IOException {
//1. 建立Request
SearchRequest 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());
}
}
布爾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代碼實作
@Test
public void booleanMatchQuery() throws IOException {
//1. 建立Request
SearchRequest request = new SearchRequest(index);
request.types(type);
//2. 指定查詢條件
SearchSourceBuilder builder = new SearchSourceBuilder();
//----------------------------------------------- 選擇AND或者OR
builder.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());
}
}
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代碼實作
@Test
public void multiMatchQuery() throws IOException {
//1. 建立Request
SearchRequest 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());
}
}
其他查詢
id查詢
根據id查詢 where id = ?
# id查詢
GET /sms-logs-index/sms-logs-type/1
代碼實作方式
// Java代碼實作
@Test
public void findById() throws IOException {
//1. 建立GetRequest
GetRequest request = new GetRequest(index,type,"1");
//2. 執行查詢
GetResponse resp = client.get(request, RequestOptions.DEFAULT);
//3. 輸出結果
System.out.println(resp.getSourceAsMap());
}
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代碼實作
@Test
public void findByIds() throws IOException {
//1. 建立SearchRequest
SearchRequest 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());
}
}
prefix查詢
字首查詢，可以通過一個關鍵字去指定一個Field的字首，進而查詢到指定的文檔。
#prefix 查詢
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"prefix": {
"corpName": {
"value": "途虎"
}
}
}
}
代碼實作方式
// Java實作字首查詢
@Test
public void findByPrefix() throws IOException {
//1. 建立SearchRequest
SearchRequest 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());
}
}
fuzzy查詢
模糊查詢，我們輸入字元的大概，ES就可以去根據輸入的内容大概去比對一下結果。
# fuzzy查詢
POST /sms-logs-index/sms-logs-type/_search
{
"query":
{
"fuzzy": {
"corpName": {
"value": "盒馬先生",
"prefix_length": 2 # 指定前面幾個字元是不允許出現錯誤的
}
}
}
}
代碼實作方式
// Java代碼實作Fuzzy查詢
@Test
public void findByFuzzy() throws IOException {
//1. 建立SearchRequest
SearchRequest 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());
}
}
wildcard查詢
通配查詢，和MySQL中的like是一個套路，可以在查詢時，在字元串中指定通配符* 和占位符？，*的範圍比？廣泛
# wildcard 查詢
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"wildcard": {
"corpName": {
"value": "中國*" # 可以使用*和？指定通配符和占位符
}
}
}
}
代碼實作方式
// Java代碼實作Wildcard查詢
@Test
public void findByWildCard() throws IOException {
//1. 建立SearchRequest
SearchRequest 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());
}
}
range查詢
範圍查詢，隻針對數值類型，對某一個Field進行大于或者小于的範圍指定
# range 查詢
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"range": {
"fee": {
"gt": 5,
"lte": 10
# 可以使用 gt：> gte：>= lt：< lte：<=
}
}
}
}
代碼實作方式
// Java實作range範圍查詢
@Test
public void findByRange() throws IOException {
//1. 建立SearchRequest
SearchRequest 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());
}
}
regexp查詢
正則查詢，通過你編寫的正規表達式去比對内容。
Ps：prefix，fuzzy，wildcard和regexp查詢效率相對比較低，要求效率比較高時，避免去使用
# regexp 查詢
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"regexp": {
"mobile": "180[0-9]{8}" # 編寫正則
}
}
}
代碼實作方式
// Java代碼實作正則查詢
@Test
public void findByRegexp() throws IOException {
//1. 建立SearchRequest
SearchRequest 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());
}
}
深分頁Scroll
ES對from + size是有限制的，from和size二者之和不能超過1W
原理：
Scroll查詢方式，不适合做實時的查詢
- from+size在ES查詢資料的方式：
- 第一步現将使用者指定的關鍵進行分詞。
- 第二步将詞彙去分詞庫中進行檢索，得到多個文檔的id。
- 第三步去各個分片中去拉取指定的資料。耗時較長。
- 第四步将資料根據score進行排序。耗時較長。
- 第五步根據from的值，将查詢到的資料舍棄一部分。
- 第六步傳回結果。
- scroll+size在ES查詢資料的方式：
- 第一步現将使用者指定的關鍵進行分詞。
- 第二步将詞彙去分詞庫中進行檢索，得到多個文檔的id。
- 第三步将文檔的id存放在一個ES的上下文中。
- 第四步根據你指定的size的個數去ES中檢索指定個數的資料，拿完資料的文檔id，會從上下文中移除。
- 第五步如果需要下一頁資料，直接去ES的上下文中，找後續内容。
- 第六步循環第四步和第五步
# 執行scroll查詢，傳回第一頁資料，并且将文檔id資訊存放在ES上下文中，指定生存時間1m
POST /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分頁
@Test
public void scrollQuery() throws IOException {
//1. 建立SearchRequest
SearchRequest 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，source
SearchResponse 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. 循環 - 建立SearchScrollRequest
SearchScrollRequest 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. 建立CLearScrollRequest
ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
//11. 指定ScrollId
clearScrollRequest.addScrollId(scrollId);
//12. 删除ScrollId
ClearScrollResponse clearScrollResponse = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
//13. 輸出結果
System.out.println("删除scroll：" + clearScrollResponse.isSucceeded());
}
delete-by-query
根據term，match等查詢方式去删除大量的文檔
Ps：如果你需要删除的内容，是index下的大部分資料，推薦建立一個全新的index，将保留的文檔内容，添加到全新的索引
# delete-by-query
POST /sms-logs-index/sms-logs-type/_delete_by_query
{
"query": {
"range": {
"fee": {
"lt": 4
}
}
}
}
代碼實作方式
// Java代碼實作
@Test
public void deleteByQuery() throws IOException {
//1. 建立DeleteByQueryRequest
DeleteByQueryRequest 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());
}
複合查詢
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查詢
@Test
public void BoolQuery() throws IOException {
//1. 建立SearchRequest
SearchRequest 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());
}
}
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查詢
@Test
public void BoostingQuery() throws IOException {
//1. 建立SearchRequest
SearchRequest 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());
}
}
filter查詢
query，根據你的查詢條件，去計算文檔的比對度得到一個分數，并且根據分數進行排序，不會做緩存的。
filter，根據你的查詢條件去查詢文檔，不去計算分數，而且filter會對經常被過濾的資料進行緩存。
# filter查詢
POST /sms-logs-index/sms-logs-type/_search
{
"query": {
"bool": {
"filter": [
{
"term": {
"corpName": "盒馬鮮生"
}
},
{
"range": {
"fee": {
"lte": 4
}
}
}
]
}
}
}
代碼實作方式
// Java實作filter操作
@Test
public void filter() throws IOException {
//1. SearchRequest
SearchRequest 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());
}
}
高亮查詢
高亮查詢就是你使用者輸入的關鍵字，以一定的特殊樣式展示給使用者，讓使用者知道為什麼這個結果被檢索出來。
高亮展示的資料，本身就是文檔中的一個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實作高亮查詢
@Test
public void highLightQuery() throws IOException {
//1. SearchRequest
SearchRequest 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"));
}
}
聚合查詢
ES的聚合查詢和MySQL的聚合查詢類似，ES的聚合查詢相比MySQL要強大的多，ES提供的統計資料的方式多種多樣。
# ES聚合查詢的RESTful文法
POST /index/type/_search
{
"aggs": {
"名字（agg）": {
"agg_type": {
"屬性": "值"
}
}
}
}
去重計數查詢
去重計數，即Cardinality，第一步先将傳回的文檔中的一個指定的field進行去重，統計一共有多少條
# 去重計數查詢 北京 上海 武漢 山西
POST /sms-logs-index/sms-logs-type/_search
{
"aggs": {
"agg": {
"cardinality": {
"field": "province"
}
}
}
}
代碼實作方式
// Java代碼實作去重計數查詢
@Test
public void cardinality() throws IOException {
//1. 建立SearchRequest
SearchRequest 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);
}
範圍統計
統計一定範圍内出現的文檔個數，比如，針對某一個Field的值在 0~100,100~200,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實作數值 範圍統計
@Test
public void range() throws IOException {
//1. 建立SearchRequest
SearchRequest 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));
}
}
統計聚合查詢
他可以幫你查詢指定Field的最大值，最小值，平均值，平方和等
使用：extended_stats
# 統計聚合查詢
POST /sms-logs-index/sms-logs-type/_search
{
"aggs": {
"agg": {
"extended_stats": {
"field": "fee"
}
}
}
}
代碼實作方式
// Java實作統計聚合查詢
@Test
public void extendedStats() throws IOException {
//1. 建立SearchRequest
SearchRequest 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
地圖經緯度搜尋
ES中提供了一個資料類型 geo_point，這個類型就是用來存儲經緯度的。
建立一個帶geo_point類型的索引，并添加測試資料
# 建立一個索引，指定一個name，locaiton
PUT /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
}
}
ES的地圖檢索方式
| 文法 | 說明 |
|---|---|
| geo_distance | 直線距離檢索方式 |
| geo_bounding_box | 以兩個點确定一個矩形，擷取在矩形内的全部資料 |
| geo_polygon | 以多個點，确定一個多邊形，擷取多邊形内的全部資料 |
基于RESTful實作地圖檢索
geo_distance
# geo_distance
POST /map/map/_search
{
"query": {
"geo_distance": {
"location": { # 确定一個點
"lon": 116.433733,
"lat": 39.908404
},
"distance": 3000, # 确定半徑
"distance_type": "arc" # 指定形狀為圓形
}
}
}
geo_bounding_box
# geo_bounding_box
POST /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_polygon
POST /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
}
]
}
}
}
}
Java實作geo_polygon
// 基于Java實作geo_polygon查詢
@Test
public void geoPolygon() throws IOException {
//1. SearchRequest
SearchRequest 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());
}
}
![Java小案例——随機數猜測随機數猜測[圖]](data:image/gif;base64,R0lGODlhAQABAIAAAP///wAAACwAAAAAAQABAAACAkQBADs=)