Demo介紹
學習rabbitmq和elasticsearch後的小練習，主要功能點介紹：
1.elasticsearch實現搜尋、條件查詢和分頁；
2.搜尋周邊酒店資訊
3.酒店競價排名；
4.後臺管理；
RabbitMQ介紹
微服務間通訊有同步和非同步兩種方式：
同步通訊：就像打電話，需要實時響應（Feign呼叫就屬於同步方式）。
非同步通訊：就像發郵件，不需要馬上回復（RabbitMQ）。
RabbitMQ中的一些角色：
publisher：生產者
consumer：消費者
exchange個：交換機，負責訊息路由
queue：佇列，儲存訊息
virtualHost：虛擬主機，隔離不同租戶的exchange、queue、訊息的隔離
RabbitMQ安裝（基於Docker）
從docker倉庫拉去
docker pull rabbitmq:3-management
安裝
docker run \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123321 \
--name mq \
--hostname mq1 \
-p 15672:15672 \
-p 5672:5672 \
-d \
rabbitmq:3-management
這裡第二行是設定登入管理介面的使用者名稱，第三行是密碼，第四行是容器名字，第五行是主機名稱，第六行是管理介面所需要暴露的埠，第七行是RabbitMQ程序埠。
Elasticsearch介紹
elasticsearch是一款非常強大的開源搜尋引擎，具備非常多強大功能，可以幫助我們從海量資料中快速找到需要的內容
Elasticsearch 使用一種稱為 倒排索引 的結構，它適用於快速的全文搜尋。一個倒排索引由文件中所有不重複詞的列表構成，對於其中每個詞，有一個包含它的文件列表。
elasticsearch是面向文件（Document）儲存的，可以是資料庫中的一條商品資料，一個訂單資訊。文件資料會被序列化為json格式後儲存在elasticsearch中，而Json文件中往往包含很多的欄位（Field），類似於資料庫中的列。
索引（Index），就是相同型別的文件的集合。
資料庫的表會有約束資訊，用來定義表的結構、欄位的名稱、型別等資訊。因此，索引庫中就有對映（mapping），是索引中文件的欄位約束資訊，類似表的結構約束。
和MYSQL對比：
Mysql：擅長事務型別操作，可以確保資料的安全和一致性
Elasticsearch：擅長海量資料的搜尋、分析、計算.
Elasticsearch安裝（基於Docker）
在用elasticsearch之前可以安裝kibana（視覺化圖形工具）
因為我們還需要部署kibana容器，因此需要讓es和kibana容器互聯。這裡先建立一個網路：
docker network create es-net
kibana拉取
docker pull kibana:7.12.1
安裝
docker run -d \
--name kibana \
-e ELASTICSEARCH_HOSTS=http://es:9200 \
--network=es-net \
-p 5601:5601 \
kibana:7.12.1
第三行是kibana的地址，es是上面建立的網路，來確保兩個在同一網路環境
es拉取
docker pull elasticsearch:7.12.1
es安裝
docker run -d \
--name es \
-e "ES_JAVA_OPTS=-Xms512m -Xmx512m" \
-e "discovery.type=single-node" \
-v es-data:/usr/share/elasticsearch/data \
-v es-plugins:/usr/share/elasticsearch/plugins \
--privileged \
--network es-net \
-p 9200:9200 \
-p 9300:9300 \
elasticsearch:7.12.1
第三行是指定es的執行記憶體大小，可根據自己的機器修改，第四行是指定為非叢集模式，五六行是掛在資料卷的位置。
RabbitMQ使用
通過SpringAMQP是基於RabbitMQ封裝的一套模板，並且還利用SpringBoot對其實現了自動裝配。
匯入SpringAMQP依賴
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
rabbitMQ---yml配置
spring:
rabbitmq:
host: 你的伺服器ip地址
port: 5672
username: 配置時設定的使用者名稱
password: 密碼
virtual-host: /
Basic Queue 簡單佇列模型
訊息傳送（publisher）
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
@Autowired
private RabbitTemplate rabbitTemplate; @Test
public void testSimpleQueue() {
// 佇列名稱
String queueName = "simple.queue";
// 訊息
String message = "hello, spring amqp!";
// 傳送訊息
rabbitTemplate.convertAndSend(queueName, message);
}
}
訊息接收（consumer）
在consumer服務的listener包中新建一個類SpringRabbitListener
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component; @Component
public class SpringRabbitListener { @RabbitListener(queues = "simple.queue")
public void listenSimpleQueueMessage(String msg) throws InterruptedException {
System.out.println("spring 消費者接收到訊息：【" + msg + "】");
}
}
WorkQueue
WorkQueue也被稱為（Task queues），任務模型。簡單來說就是讓多個消費者繫結到一個佇列，共同消費佇列中的訊息。
訊息傳送
@Test
public void testWorkQueue() throws InterruptedException {
// 佇列名稱
String queueName = "simple.queue";
// 訊息
String message = "hello, message_";
for (int i = 0; i < 50; i++) {
// 傳送訊息
rabbitTemplate.convertAndSend(queueName, message + i);
Thread.sleep(20);
}
}
訊息接收
@RabbitListener(queues = "simple.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
System.out.println("消費者1接收到訊息：【" + msg + "】" + LocalTime.now());
Thread.sleep(20);
} @RabbitListener(queues = "simple.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
System.err.println("消費者2........接收到訊息：【" + msg + "】" + LocalTime.now());
Thread.sleep(200);
}
釋出/訂閱模型
在訂閱模型中，多了一個exchange角色，Exchange（交換機）只負責轉發訊息，不具備儲存訊息的能力。
訂閱模型不像簡單佇列模型它需要將佇列繫結在交換機上
Fanout模型
繫結佇列和交換機在消費者consumer服務中
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration; @Configuration
public class FanoutConfig {
/**
* 宣告交換機
* @return Fanout型別交換機
*/
@Bean
public FanoutExchange fanoutExchange(){
return new FanoutExchange("itcast.fanout");
} /**
* 第1個佇列
*/
@Bean
public Queue fanoutQueue1(){
return new Queue("fanout.queue1");
} /**
* 繫結佇列和交換機
*/
@Bean
public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
} /**
* 第2個佇列
*/
@Bean
public Queue fanoutQueue2(){
return new Queue("fanout.queue2");
} /**
* 繫結佇列和交換機
*/
@Bean
public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
}
}
訊息傳送
@Test
public void testFanoutExchange() {
// 佇列名稱
String exchangeName = "itcast.fanout";
// 訊息
String message = "hello, everyone!";
rabbitTemplate.convertAndSend(exchangeName, "", message);
}
訊息接收
@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
System.out.println("消費者1接收到Fanout訊息：【" + msg + "】");
} @RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
System.out.println("消費者2接收到Fanout訊息：【" + msg + "】");
}
Direct模型
基於註解宣告佇列和交換機和接收訊息
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue1"),
exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
System.out.println("消費者接收到direct.queue1的訊息：【" + msg + "】");
} @RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue2"),
exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
System.out.println("消費者接收到direct.queue2的訊息：【" + msg + "】");
}
訊息傳送
@Test
public void testSendDirectExchange() {
// 交換機名稱
String exchangeName = "itcast.direct";
// 訊息
String message = "message ";
// 傳送訊息
rabbitTemplate.convertAndSend(exchangeName, "red", message);
}
配置JSON轉換器
顯然，JDK序列化方式並不合適。我們希望訊息體的體積更小、可讀性更高，因此可以使用JSON方式來做序列化和反序列化。
在publisher和consumer兩個服務中都引入依賴：
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.9.10</version>
</dependency>
配置訊息轉換器。
在啟動類中新增一個Bean即可：
@Bean
public MessageConverter jsonMessageConverter(){
return new Jackson2JsonMessageConverter();
}
小結：服務者publisher訊息傳送只需要管要傳送的交換機名字、Binding和訊息，而消費者需要監聽是否收到訊息
elasticsearch使用
索引庫的CRUD
首先開啟ip:5601
建立索引庫和對映
PUT /索引庫名稱
{
"mappings": {
"properties": {
"欄位名":{
"type": "text",
"analyzer": "ik_smart"
},
"欄位名2":{
"type": "keyword",
"index": "false"
},
"欄位名3":{
"properties": {
"子欄位": {
"type": "keyword"
}
}
},
// ...略
}
}
}
查詢索引庫
GET /索引庫名
修改索引庫
PUT /索引庫名/_mapping
{
"properties": {
"新欄位名":{
"type": "integer"
}
}
}
刪除索引庫
DELETE /索引庫名
文件操作
新增文件
POST /索引庫名/_doc/文件id
{
"欄位1": "值1",
"欄位2": "值2",
"欄位3": {
"子屬性1": "值3",
"子屬性2": "值4"
},
// ...
}
例：
POST /test/_doc/1
{
"info": "Java講師",
"email": "[email protected]",
"name": {
"firstName": "雲",
"lastName": "趙"
}
}
查詢文件
GET /{索引庫名稱}/_doc/{id}
例：
GET /test/_doc/1
刪除文件
DELETE /{索引庫名}/_doc/id值
修改文件
全量修改---全量修改是覆蓋原來的文件
PUT /{索引庫名}/_doc/文件id
{
"欄位1": "值1",
"欄位2": "值2",
// ... 略
}
增量修改---增量修改是隻修改指定id匹配的文件中的部分欄位
POST /heima/_update/1
{
"doc": {
"email": "[email protected]"
}
}
RestAPI---forJava
建立索引庫
PUT /hotel
{
"mappings": {
"properties": {
"id": {
"type": "keyword"
},
"name":{
"type": "text",
"analyzer": "ik_max_word",
"copy_to": "all"
},
"address":{
"type": "keyword",
"index": false
},
"price":{
"type": "integer"
},
"score":{
"type": "integer"
},
"brand":{
"type": "keyword",
"copy_to": "all"
},
"city":{
"type": "keyword",
"copy_to": "all"
},
"starName":{
"type": "keyword"
},
"business":{
"type": "keyword"
},
"location":{
"type": "geo_point"
},
"pic":{
"type": "keyword",
"index": false
},
"all":{
"type": "text",
"analyzer": "ik_max_word"
}
}
}
}
幾個特殊欄位說明：
location：地理座標，裡面包含精度、緯度
all：一個組合欄位，其目的是將多欄位的值 利用copy_to合併，提供給使用者搜尋
初始化RestClient
引入es的RestHighLevelClient依賴
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
</dependency>
因為SpringBoot預設的ES版本是7.6.2，所以我們需要覆蓋預設的ES版本
<properties>
<java.version>1.8</java.version>
<elasticsearch.version>7.12.1</elasticsearch.version>
</properties>
初始化RestHighLevelClient
import org.apache.http.HttpHost;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test; import java.io.IOException; public class HotelIndexTest {
private RestHighLevelClient client; @BeforeEach
void setUp() {
this.client = new RestHighLevelClient(RestClient.builder(
HttpHost.create("http://192.168.150.101:9200")
));
} @AfterEach
void tearDown() throws IOException {
this.client.close();
}
}
建立索引庫
@Test
void createHotelIndex() throws IOException {
// 1.建立Request物件
CreateIndexRequest request = new CreateIndexRequest("hotel");
// 2.準備請求的引數：DSL語句
request.source(*DSL語句*, XContentType.JSON);
// 3.傳送請求
client.indices().create(request, RequestOptions.DEFAULT);
}
刪除索引庫
@Test
void testDeleteHotelIndex() throws IOException {
// 1.建立Request物件
DeleteIndexRequest request = new DeleteIndexRequest("hotel");
// 2.傳送請求
client.indices().delete(request, RequestOptions.DEFAULT);
}
判斷索引庫是否存在
@Test
void testExistsHotelIndex() throws IOException {
// 1.建立Request物件
GetIndexRequest request = new GetIndexRequest("hotel");
// 2.傳送請求
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);
// 3.輸出
System.err.println(exists ? "索引庫已經存在！" : "索引庫不存在！");
}
RestClient操作文件
新增文件
@Test
void testAddDocument() throws IOException {
// 1.根據id查詢酒店資料
Hotel hotel = hotelService.getById(61083L); // 2.將hotel 轉json
String json = JSON.toJSONString(hotel ); // 1.準備Request物件
IndexRequest request = new IndexRequest("hotel").id(hotelDoc.getId().toString());
// 2.準備Json文件
request.source(json, XContentType.JSON);
// 3.傳送請求
client.index(request, RequestOptions.DEFAULT);
}
查詢文件（根據id）
@Test
void testGetDocumentById() throws IOException {
// 1.準備Request
GetRequest request = new GetRequest("hotel", "61082");
// 2.傳送請求，得到響應
GetResponse response = client.get(request, RequestOptions.DEFAULT);
// 3.解析響應結果
String json = response.getSourceAsString(); HotelDoc hotel = JSON.parseObject(json, Hotel.class);
System.out.println(hotel);
}
刪除文件
@Test
void testDeleteDocument() throws IOException {
// 1.準備Request
DeleteRequest request = new DeleteRequest("hotel", "61083");
// 2.傳送請求
client.delete(request, RequestOptions.DEFAULT);
}
修改文件
@Test
void testUpdateDocument() throws IOException {
// 1.準備Request
UpdateRequest request = new UpdateRequest("hotel", "61083");
// 2.準備請求引數
request.doc(
"price", "952",
"starName", "四鑽"
);
// 3.傳送請求
client.update(request, RequestOptions.DEFAULT);
}
批量匯入文件
@Test
void testBulkRequest() throws IOException {
// 批量查詢酒店資料
List<Hotel> hotels = hotelService.list(); // 1.建立Request
BulkRequest request = new BulkRequest();
// 2.準備引數，新增多個新增的Request
for (Hotel hotel : hotels) { // 2.1.建立新增文件的Request物件
request.add(new IndexRequest("hotel")
.id(hotel.getId().toString())
.source(JSON.toJSONString(hotel), XContentType.JSON));
}
// 3.傳送請求
client.bulk(request, RequestOptions.DEFAULT);
}
DSL查詢分類
查詢所有：查詢出所有資料，一般測試用。例如：match_all
全文檢索（full text）查詢：利用分詞器對使用者輸入內容分詞，然後去倒排索引庫中匹配。例如：
match查詢：單欄位查詢
multi_match查詢：多欄位查詢，任意一個欄位符合條件就算符合查詢條件
match和multi_match的區別是什麼？
match：根據一個欄位查詢
multi_match：根據多個欄位查詢，參與查詢欄位越多，查詢效能越差
精確查詢：根據精確詞條值查詢資料，一般是查詢keyword、數值、日期、boolean等型別欄位。例如：
ids 根據id查詢
range 根據值的範圍查詢
term 根據詞條精確值查詢
地理（geo）查詢：根據經緯度查詢。例如：
geo_distance 附近查詢，也叫做距離查詢
geo_bounding_box 矩形範圍查詢
複合（compound）查詢：複合查詢可以將上述各種查詢條件組合起來，合併查詢條件。例如：
fuction score：算分函式查詢，可以控制文件相關性算分，控制文件排名
bool query：布林查詢，利用邏輯關係組合多個其它的查詢，實現複雜搜尋
相關性算分
當我們利用match查詢時，文件結果會根據與搜尋詞條的關聯度打分（_score），返回結果時按照分值降序排列
function score 查詢中包含四部分內容：
原始查詢條件：query部分，基於這個條件搜尋文件，並且基於BM25演算法給文件打分，原始算分（query score)
過濾條件：filter部分，符合該條件的文件才會重新算分
算分函式：符合filter條件的文件要根據這個函式做運算，得到的函式算分（function score），有四種函式
weight：函式結果是常量
field_value_factor：以文件中的某個欄位值作為函式結果
random_score：以隨機數作為函式結果
script_score：自定義算分函式演算法
運算模式：算分函式的結果、原始查詢的相關性算分，兩者之間的運算方式，包括：
multiply：相乘
replace：用function score替換query score
其它，例如：sum、avg、max、min
function score的執行流程如下：
1）根據原始條件查詢搜尋文件，並且計算相關性算分，稱為原始算分（query score）
2）根據過濾條件，過濾文件
3）符合過濾條件的文件，基於算分函式運算，得到函式算分（function score）
4）將原始算分（query score）和函式算分（function score）基於運算模式做運算，得到最終結果，作為相關性算分。
因此，其中的關鍵點是：
過濾條件：決定哪些文件的算分被修改
算分函式：決定函式算分的演算法
運算模式：決定最終算分結果
示例：
GET /hotel/_search
{
"query": {
"function_score": {
"query": { .... }, // 原始查詢，可以是任意條件
"functions": [ // 算分函式
{
"filter": { // 滿足的條件，品牌必須是如家
"term": {
"brand": "如家"
}
},
"weight": 2 // 算分權重為2
}
],
"boost_mode": "sum" // 加權模式，求和
}
}
}
布林查詢（bool）
布林查詢是一個或多個查詢子句的組合，每一個子句就是一個子查詢。子查詢的組合方式有：
must：必須匹配每個子查詢，類似“與”
should：選擇性匹配子查詢，類似“或”
must_not：必須不匹配，不參與算分，類似“非”
filter：必須匹配，不參與算分
每一個不同的欄位，其查詢的條件、方式都不一樣，必須是多個不同的查詢，而要組合這些查詢，就必須用bool查詢了。
需要注意的是，搜尋時，參與打分的欄位越多，查詢的效能也越差。因此這種多條件查詢時，建議這樣做：
搜尋框的關鍵字搜尋，是全文檢索查詢，使用must查詢，參與算分
其它過濾條件，採用filter查詢。不參與算分
示例
GET /hotel/_search
{
"query": {
"bool": {
"must": [
{"term": {"city": "上海" }}
],
"should": [
{"term": {"brand": "皇冠假日" }},
{"term": {"brand": "華美達" }}
],
"must_not": [
{ "range": { "price": { "lte": 500 } }}
],
"filter": [
{ "range": {"score": { "gte": 45 } }}
]
}
}
}
查詢的語法基本一致：
GET /indexName/_search
{
"query": {
"查詢型別": {
"查詢條件": "條件值"
}
}
}
搜尋結果處理
排序
普通欄位排序
排序條件是一個數組，也就是可以寫多個排序條件。按照宣告的順序，當第一個條件相等時，再按照第二個條件排序，以此類推
GET /indexName/_search
{
"query": {
"match_all": {}
},
"sort": [
{
"FIELD": "desc" // 排序欄位、排序方式ASC、DESC
}
]
}
地理座標排序
GET /indexName/_search
{
"query": {
"match_all": {}
},
"sort": [
{
"_geo_distance" : {
"FIELD" : "緯度，經度", // 文件中geo_point型別的欄位名、目標座標點
"order" : "asc", // 排序方式
"unit" : "km" // 排序的距離單位
}
}
]
}
這個查詢的含義是：
指定一個座標，作為目標點
計算每一個文件中，指定欄位（必須是geo_point型別）的座標 到目標點的距離是多少
根據距離排序
分頁
基本的分頁
GET /hotel/_search
{
"query": {
"match_all": {}
},
"from": 0, // 分頁開始的位置，預設為0
"size": 10, // 期望獲取的文件總數
"sort": [
{"price": "asc"}
]
}
深度分頁問題
GET /hotel/_search
{
"query": {
"match_all": {}
},
"from": 990, // 分頁開始的位置，預設為0
"size": 10, // 期望獲取的文件總數
"sort": [
{"price": "asc"}
]
}
高亮
GET /hotel/_search
{
"query": {
"match": {
"FIELD": "TEXT" // 查詢條件，高亮一定要使用全文檢索查詢
}
},
"highlight": {
"fields": { // 指定要高亮的欄位
"FIELD": {
"pre_tags": "<em>", // 用來標記高亮欄位的前置標籤
"post_tags": "</em>" // 用來標記高亮欄位的後置標籤
}
}
}
}
RestClient查詢文件
基本步驟：
第一步，建立
SearchRequest物件，指定索引庫名第二步，利用
request.source()構建DSL，DSL中可以包含查詢、分頁、排序、高亮等query()：代表查詢條件，利用QueryBuilders.matchAllQuery()構建一個match_all查詢的DSL
第三步，利用client.search()傳送請求，得到響應
- 第四步，解析響應
示例：
@Test
void testMatchAll() throws IOException {
// 1.準備Request
SearchRequest request = new SearchRequest("hotel");
// 2.準備DSL
request.source()
.query(QueryBuilders.matchAllQuery());
// 3.傳送請求
SearchResponse response = client.search(request, RequestOptions.DEFAULT); // 4.解析響應
handleResponse(response);
} private void handleResponse(SearchResponse response) {
// 4.解析響應
SearchHits searchHits = response.getHits();
// 4.1.獲取總條數
long total = searchHits.getTotalHits().value;
System.out.println("共搜尋到" + total + "條資料");
// 4.2.文件陣列
SearchHit[] hits = searchHits.getHits();
// 4.3.遍歷
for (SearchHit hit : hits) {
// 獲取文件source
String json = hit.getSourceAsString();
// 反序列化
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
System.out.println("hotelDoc = " + hotelDoc);
}
}
match查詢
@Test
void testMatch() throws IOException {
// 1.準備Request
SearchRequest request = new SearchRequest("hotel");
// 2.準備DSL
request.source()
.query(QueryBuilders.matchQuery("all", "如家"));
// 3.傳送請求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析響應
handleResponse(response); }
精確查詢
同上換成
QueryBuilders.termQuery（“欄位”，“值”）；
QueryBuilders.rangeQuery（“欄位”）.gte(min).lte(max);
布林查詢
與其它查詢的差別同樣是在查詢條件的構建，QueryBuilders，結果解析等其他程式碼完全不變。
@Test
void testBool() throws IOException {
// 1.準備Request
SearchRequest request = new SearchRequest("hotel");
// 2.準備DSL
// 2.1.準備BooleanQuery
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
// 2.2.新增term
boolQuery.must(QueryBuilders.termQuery("city", "杭州"));
// 2.3.新增range
boolQuery.filter(QueryBuilders.rangeQuery("price").lte(250)); request.source().query(boolQuery);
// 3.傳送請求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析響應
handleResponse(response); }
排序、分頁
@Test
void testPageAndSort() throws IOException {
// 頁碼，每頁大小
int page = 1, size = 5; // 1.準備Request
SearchRequest request = new SearchRequest("hotel");
// 2.準備DSL
// 2.1.query
request.source().query(QueryBuilders.matchAllQuery());
// 2.2.排序 sort
request.source().sort("price", SortOrder.ASC);
// 2.3.分頁 from、size
request.source().from((page - 1) * size).size(5);
// 3.傳送請求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析響應
handleResponse(response); }
高亮
@Test
void testHighlight() throws IOException {
// 1.準備Request
SearchRequest request = new SearchRequest("hotel");
// 2.準備DSL
// 2.1.query
request.source().query(QueryBuilders.matchQuery("all", "如家"));
// 2.2.高亮
request.source().highlighter(new HighlightBuilder().field("name").requireFieldMatch(false));
// 3.傳送請求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析響應
handleResponse(response); }
高粱結果解析
private void handleResponse(SearchResponse response) {
// 4.解析響應
SearchHits searchHits = response.getHits();
// 4.1.獲取總條數
long total = searchHits.getTotalHits().value;
System.out.println("共搜尋到" + total + "條資料");
// 4.2.文件陣列
SearchHit[] hits = searchHits.getHits();
// 4.3.遍歷
for (SearchHit hit : hits) {
// 獲取文件source
String json = hit.getSourceAsString();
// 反序列化
HotelDoc hotelDoc = JSON.parseObject(json, HotelDoc.class);
// 獲取高亮結果
Map<String, HighlightField> highlightFields = hit.getHighlightFields();
if (!CollectionUtils.isEmpty(highlightFields)) {
// 根據欄位名獲取高亮結果
HighlightField highlightField = highlightFields.get("name");
if (highlightField != null) {
// 獲取高亮值
String name = highlightField.getFragments()[0].string();
// 覆蓋非高亮結果
hotelDoc.setName(name);
}
}
System.out.println("hotelDoc = " + hotelDoc);
}
}
資料聚合
聚合（aggregations）可以讓我們極其方便的實現對資料的統計、分析、運算。例如：
什麼品牌的手機最受歡迎？
這些手機的平均價格、最高價格、最低價格？
這些手機每月的銷售情況如何？
實現這些統計功能的比資料庫的sql要方便的多，而且查詢速度非常快，可以實現近實時搜尋效果。
聚合常見的有三類：
桶（Bucket）聚合：用來對文件做分組
TermAggregation：按照文件欄位值分組，例如按照品牌值分組、按照國家分組
Date Histogram：按照日期階梯分組，例如一週為一組，或者一月為一組
度量（Metric）聚合：用以計算一些值，比如：最大值、最小值、平均值等
Avg：求平均值
Max：求最大值
Min：求最小值
Stats：同時求max、min、avg、sum等
管道（pipeline）聚合：其它聚合的結果為基礎做聚合
注意：參加聚合的欄位必須是keyword、日期、數值、布林型別
DSL實現
GET /hotel/_search
{
"size": 0, // 設定size為0，結果中不包含文件，只包含聚合結果
"aggs": { // 定義聚合
"brandAgg": { //給聚合起個名字
"terms": { // 聚合的型別，按照品牌值聚合，所以選擇term
"field": "brand", // 參與聚合的欄位
"size": 20 // 希望獲取的聚合結果數量
}
}
}
}
聚合結果排序
GET /hotel/_search
{
"size": 0,
"aggs": {
"brandAgg": {
"terms": {
"field": "brand",
"order": {
"_count": "asc" // 按照_count升序排列
},
"size": 20
}
}
}
}
限定聚合範圍
預設情況下，Bucket聚合是對索引庫的所有文件做聚合，但真實場景下，使用者會輸入搜尋條件，因此聚合必須是對搜尋結果聚合。那麼聚合必須新增限定條件。
GET /hotel/_search
{
"query": {
"range": {
"price": {
"lte": 200 // 只對200元以下的文件聚合
}
}
},
"size": 0,
"aggs": {
"brandAgg": {
"terms": {
"field": "brand",
"size": 20
}
}
}
}
RestAPI
@Override
public Map<String, List<String>> filters(RequestParams params) {
try {
// 1.準備Request
SearchRequest request = new SearchRequest("hotel");
// 2.準備DSL
// 2.1.query
buildBasicQuery(params, request);
// 2.2.設定size
request.source().size(0);
// 2.3.聚合
buildAggregation(request);
// 3.發出請求
SearchResponse response = client.search(request, RequestOptions.DEFAULT);
// 4.解析結果
Map<String, List<String>> result = new HashMap<>();
Aggregations aggregations = response.getAggregations();
// 4.1.根據品牌名稱，獲取品牌結果
List<String> brandList = getAggByName(aggregations, "brandAgg");
result.put("品牌", brandList);
// 4.2.根據品牌名稱，獲取品牌結果
List<String> cityList = getAggByName(aggregations, "cityAgg");
result.put("城市", cityList);
// 4.3.根據品牌名稱，獲取品牌結果
List<String> starList = getAggByName(aggregations, "starAgg");
result.put("星級", starList); return result;
} catch (IOException e) {
throw new RuntimeException(e);
}
} private void buildAggregation(SearchRequest request) {
request.source().aggregation(AggregationBuilders
.terms("brandAgg")
.field("brand")
.size(100)
);
request.source().aggregation(AggregationBuilders
.terms("cityAgg")
.field("city")
.size(100)
);
request.source().aggregation(AggregationBuilders
.terms("starAgg")
.field("starName")
.size(100)
);
} private List<String> getAggByName(Aggregations aggregations, String aggName) {
// 4.1.根據聚合名稱獲取聚合結果
Terms brandTerms = aggregations.get(aggName);
// 4.2.獲取buckets
List<? extends Terms.Bucket> buckets = brandTerms.getBuckets();
// 4.3.遍歷
List<String> brandList = new ArrayList<>();
for (Terms.Bucket bucket : buckets) {
// 4.4.獲取key
String key = bucket.getKeyAsString();
brandList.add(key);
}
return brandList;
}