ElasticSearch快速上手

1
{
2
    "age": 21,
3
    "weight": 52.1,
4
    "isMarried": false,
5
    "info": "我是一个路人甲",
6
    "email": "123@qq.com",
7
    "score": [99.1, 99.5, 98.9],
8
    "name": {
9
        "firstName": "云",
10
        "lastName": "赵"
11
    }
12
}

1
PUT /namelist/_mapping
2
{
3
  "properties": {
4
    "name": {
5
      "type": "text"
6
    },
7
    "info": {
8
      "type": "text"
9
    },
10
,
11
    "all": {
12
      "type": "text",
13
      "copy_to": ["name_info"]
14
    }
15
  }
16
}

1
GET /namelist/_doc/1

1
        // 1. 创建索引请求
2
        CreateIndexRequest request = new CreateIndexRequest("hotel");
3
        // 2. 设置索引参数
4
        request.source(MAPPING_TEMPLATE, XContentType.JSON);
5
        // 3. 客户端发送请求，获取响应
6
        client.indices().create(request, RequestOptions.DEFAULT);

1
        client.indices().delete(new DeleteIndexRequest("hotel"), RequestOptions.DEFAULT);

1
    client.indices().get(new GetIndexRequest("hotel"), RequestOptions.DEFAULT)

1
        // 获取酒店数据
2
        HotelDoc hotelDoc = new HotelDoc(hotelService.getById(36934L));
3

4
        // 准备Request对象
5
        IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
6
        request.source(JSON.toJSONString(hotelDoc), XContentType.JSON);
7

8
        // 发送请求
9
        client.index(request, RequestOptions.DEFAULT);

1
        GetRequest request = new GetRequest("hotel", "36934");
2
        GetResponse response = client.get(request, RequestOptions.DEFAULT);
3
        if (response.isExists()) {
4
            System.out.println(response.getSourceAsString());
5
            HotelDoc res = JSON.parseObject(response.getSourceAsString(), HotelDoc.class))
6
        }else {
7
            System.out.println("数据不存在");
8
        }

1
        DeleteRequest request = new DeleteRequest("hotel", "36934");
2
        client.delete(request, RequestOptions.DEFAULT);

1
        // 准备Request对象
2
        UpdateRequest request = new UpdateRequest("hotel", "36934");
3
        // 设置更新数据(局部更新)
4
        request.doc(
5
                "price", 1000,
6
                "city", "北京"
7
        );
8
        // 发送请求
9
        client.update(request, RequestOptions.DEFAULT);

1
    List<Hotel> list = hotelService.list();
2
    // 生成BulkRequest，用于后续接收请求
3
        BulkRequest request = new BulkRequest();
4
        for (Hotel hotel : list) {
5
            HotelDoc hotelDoc = new HotelDoc(hotel);
6
            // 添加请求而不提交
7
            request.add(new IndexRequest("hotel")
8
                    .id(hotelDoc.getId().toString())
9
                    .source(JSON.toJSONString(hotelDoc), XContentType.JSON));
10
        }
11
    // 一次性提交所有请求
12
        client.bulk(request, RequestOptions.DEFAULT);

1
GET /indexName/_search
2
{
3
  "query":{
4
    "查询类型":{
5
      "查询条件": "条件值"
6
    }
7
  }
8
}
9

10
// 查询所有
11
GET /hotel/_search
12
{
13
  "query": {
14
    "match_all": {}
15
  }
16
}

1
// 检索（部分）含有对应字段的内容
2
GET /hotel/_search
3
{
4
  "query": {
5
    "match": {
6
      "name": "外滩"
7
      "FIELD": "TEXT"
8
    }
9
  }
10
}
11

12
// 在多个字段中查询匹配的项
13
GET /hotel/_search
14
{
15
  "query": {
16
    "multi_match": {
17
      "query": "外滩如家",
18
      "fields": ["brand","name","business"]
19
    }
20
  }
21
}

1
// term查询
2
GET /hotel/_search
3
{
4
  "query": {
5
    "term": {
6
      "city.keyword": {
7
        "value": "上海"
8
      }
9
    }
10
  }
11
}
12

13
// range查询
14
GET /hotel/_search
15
{
16
  "query": {
17
    "range": {
18
      "price": {
19
        "gte": 200,
20
        "lte": 300
21
      }
22
    }
23
  }
24
}

1
GET /hotel/_search
2
{
3
  "query": {
4
    "geo_distance": {
5
        "distance": "5km",
6
        "location": "31.21, 121.5"
7
    }
8
  }
9
}

1
# 按score进行降序查询，按price进行升序查询
2
GET /hotel/_search
3
{
4
  "query": {
5
    "match_all": {}
6
  },
7
  "sort": [
8
    {
9
      "score": "desc"
10
    },
11
    {
12
      "price": "asc"
13
    }
14
  ]
15
}

1
GET /hotel/_search
2
{
3
  "query": {
4
     "match_all": {}
5
  },
6
  "from": 10, // 分页开始的位置
7
  "size": 20, // 期望获取的文档数量
8
  "sort": [
9
    {
10
      "price": "desc"
11
    }
12
  ]
13
}

1
GET /hotel/_search
2
{
3
  "query": {
4
    "match": {
5
      "brand": "如家"
6
    }
7
  },
8
  "highlight": {
9
    "fields": {
10
      "name": {
11
        "require_field_match": "false" // 如果高亮和查询的字段不一致，则需要设为false
12
      }
13
    }
14
  }
15
}

1
        // 1. 创建查询请求
2
        SearchRequest request = new SearchRequest("hotel");
3
        // 2. 设置查询条件
4
        request.source().query(QueryBuilders.matchAllQuery());
5
        // 3. 发送请求
6
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
7
        // 4. 解析结果
8
        for (SearchHit hit : response.getHits().getHits()) {
9
            System.out.println(hit.getSourceAsString());
10
        }

1
//单字段查询
2
request.source().query(QueryBuilders.matchQuery("city", "北京"));
3

4

5
//多字段查询
6
request.source().query(QueryBuilders.multiMatchQuery("外滩","business","name"));

1
// boolean查询
2
BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();
3
// term查询
4
boolQueryBuilder.must(QueryBuilders.termQuery("city.keyword", "北京"));
5
// range查询
6
boolQueryBuilder.filter(QueryBuilders.rangeQuery("price").gte(100).lte(300));
7
request.source().query(boolQueryBuilder);

1
// 分页
2
request.source().from(0).size(5);
3
//排序
4
request.source().sort("price", SortOrder.DESC);

1
// 设置高亮字段
2
request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
3

4
// 处理高亮字段
5
for (SearchHit hit : response.getHits().getHits()) {
6
    // 获取高亮字段并进行替换
7
    String source = hit.getSourceAsString();
8
    String name = hit.getHighlightFields().get("name").getFragments()[0].string();
9
    source = source.replace(hit.getSourceAsMap().get("name").toString(), name);
10
    System.out.println(source);
11
}

1
GET /hotel/_search
2
{
3
  "query": {  // 对参与聚合的数据进行限制
4
    "range": {
5
      "price": {
6
        "gte": 100,
7
        "lte": 200
8
      }
9
    }
10
  },
11
  "size": 0,  // 展示文档的数量
12
   "aggs": {  // 定义聚合
13
    "brandAgg": {  // 聚合的名字
14
      "terms": {  // 聚合的类型
15
        "field": "brand.keyword",  // 参与聚合的字段
16
        "size": 10,  // 聚合结果的数量
17
        "order": {
18
          "_count": "asc"  // 可修改排序顺序，默认是降序排列
19
        }
20
      }
21
    }
22
  }
23
}

1
GET /hotel/_search
2
{
3
  "size": 0,
4
   "aggs": {
5
    "brandAgg": {
6
      "terms": {
7
        "field": "brand.keyword",
8
        "size": 10,
9
        "order": {
10
          "ScoreAgg.avg": "desc"  // 按照再次聚合的结果进行排序
11
        }
12
      },
13
      "aggs": {  // 对桶中的结果再进行一次聚合
14
        "ScoreAgg": {  // 取名
15
          "stats": {  // 此处包含平均值、最大值、最小值和求和
16
            "field": "score"  // 再次聚合的字段
17
          }
18
        }
19
      }
20
    }
21
  }
22
}

1
        // 1. 创建查询请求
2
        SearchRequest request = new SearchRequest("hotel");
3
        // 2. 设置查询条件
4
        request.source().size(0);
5
        request.source().aggregation(AggregationBuilders
6
                .terms("brandAgg")
7
                .field("brand.keyword")
8
                .size(10));
9
        // 3. 发送请求
10
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
11
        // 4. 解析结果
12
        Terms terms = response.getAggregations().get("brandAgg");
13
        List<? extends Terms.Bucket> buckets = terms.getBuckets();
14
        for (Terms.Bucket bucket : buckets) {
15
            System.out.println(bucket.getKeyAsString() + " : " + bucket.getDocCount());
16
        }

1
POST /_analyze
2
{
3
  "text": ["北大路可怜是我脑婆"],
4
  "analyzer": "pinyin"
5
}

1
PUT /test
2
{
3
  "settings": {
4
    "analysis": {
5
      "analyzer": {
6
        "my_analyzer": {
7
          "tokenizer": "ik_max_word",
8
          "filter": "py"
9
        }
10
      },
11
      "filter": {
12
        "py": {
13
          "type": "pinyin",
14
          "keep_full_pinyin": false,
15
          "keep_joined_full_pinyin": true,
16
          "keep_original": true,
17
          "limit_first_letter_length": 16,
18
          "remove_duplicated_term": true,
19
          "none_chinese_pinyin_tokenize": false
20
        }
21
      }
22
    }
23
  }
24
}

1
// 以下是一个示例：
2
// 自动补全的索引库
3
PUT test
4
{
5
  "mappings": {
6
    "properties": {
7
      "title":{
8
        "type": "completion"
9
      }
10
    }
11
  }
12
}
13

14
// 示例数据
15
POST test/_doc
16
{
17
  "title": ["Sony", "WH-1000XM3"]
18
}
19
POST test/_doc
20
{
21
  "title": ["SK-II", "PITERA"]
22
}
23
POST test/_doc
24
{
25
  "title": ["Nintendo", "switch"]
26
}

1
POST /test/_search
2
{
3
  "suggest": {
4
    "title_suggest": {
5
      "text": "s", // 关键字
6
      "completion": {
7
        "field": "title", // 补全字段
8
        "skip_duplicates": true, // 跳过重复的
9
        "size": 10 // 获取前10条结果
10
      }
11
    }
12
  }
13
}

1
        // 1. 创建查询请求
2
        SearchRequest request = new SearchRequest("hotel");
3
        // 2. 设置查询条件
4
        request.source().suggest(
5
                new SuggestBuilder().addSuggestion(
6
                        "mySuggest",
7
                        SuggestBuilders
8
                                .completionSuggestion("suggestion")
9
                                .prefix("sh")
10
                                .skipDuplicates(true)
11
                                .size(10)
12
                )
13
        );
14
        // 3. 发送请求
15
        SearchResponse response = client.search(request, RequestOptions.DEFAULT);
16
        // 4. 解析结果
17
        CompletionSuggestion suggest = response.getSuggest().getSuggestion("mySuggest");
18
        for (CompletionSuggestion.Entry.Option option : suggest.getOptions()) {
19
            System.out.println(option.getText().string());
20
        }