轉載：https://blog.csdn.net/weixin_42633131/article/details/82902812java
1.Elasticsearch介紹和安裝node
1.1.簡介
1.1.1.Elastic
Elastic官網：https://www.elastic.co/cn/mysql
Elastic有一條完整的產品線：Elasticsearch、Kibana、Logstash等，前面說的三個就是你們常說的ELK技術棧。git
1.1.2.Elasticsearch
Elasticsearch官網：https://www.elastic.co/cn/products/elasticsearchgithub
如上所述，Elasticsearch具有如下特色：spring
分佈式，無需人工搭建集羣（solr就須要人爲配置，使用Zookeeper做爲註冊中心）
Restful風格，一切API都遵循Rest原則，容易上手
近實時搜索，數據更新在Elasticsearch中幾乎是徹底同步的。
1.1.3.版本
目前Elasticsearch最新的版本是6.2.4，咱們就使用這個版本sql
須要JDK1.8及以上數據庫
1.2.安裝和配置
###1.2.1 下載apache
下載地址：https://www.elastic.co/downloads/past-releasesnpm
1.2.2 安裝
elasticsearch無需安裝，解壓即用。
[外鏈圖片轉存失敗(img-vQVf2nZn-1562576542887)(assets/1537967155637.png)]
1.3.運行
進入elasticsearch/bin目錄，能夠看到下面的執行文件：
雙擊運行
能夠看到綁定了兩個端口:
9300：java程序訪問的斷就
9200：瀏覽器、postman訪問接口
咱們在瀏覽器中訪問：http://127.0.0.1:9200
1.4.安裝Head插件
1.4.1.什麼是Head
ealsticsearch只是後端提供各類api，那麼怎麼直觀的使用它呢？elasticsearch-head將是一款專門針對於elasticsearch的客戶端工具
elasticsearch-head配置包，下載地址：https://github.com/mobz/elasticsearch-head
1.4.2.安裝
es5以上版本安裝head須要安裝node和grunt
第一步：從地址：https://nodejs.org/en/download/ 下載相應系統的msi，雙擊安裝。
第二步：安裝完成用cmd進入安裝目錄執行 node -v可查看版本號
第三步：執行 npm install -g grunt-cli 安裝grunt ，安裝完成後執行grunt -version查看是否安裝成功，會顯示安裝的版本號
1.4.3.配置運行
第一步：進入es安裝目錄下的config目錄，修改elasticsearch.yml文件.在文件的末尾加入如下代碼
http.cors.enabled: true
http.cors.allow-origin: "*"
node.master: true
node.data: true
1
2
3
4
而後去掉network.host: 192.168.0.1的註釋並改成network.host: 0.0.0.0，去掉cluster.name；node.name；http.port的註釋（也就是去掉#）(!!!若是出現bat閃退的現象，註釋就別去掉)
第二步：雙擊elasticsearch.bat重啓es
第三步：在https://github.com/mobz/elasticsearch-head中下載head插件，選擇下載zip
第四步：解壓到指定文件夾下，D:\environment\elasticsearch-head-master 進入該文件夾，修改D:\environment\elasticsearch-head-master\Gruntfile.js 在對應的位置加上hostname:’*’、
第五步：在D:\environment\elasticsearch-head-master 下執行npm install 安裝完成後執行grunt server 或者npm run start 運行head插件，若是不成功從新安裝grunt。成功以下
1.4.4.成功
1.5.安裝ik分詞器
ElasticSearch 默認採用分詞器， 單個字分詞 ，效果不好
搜索【IK Analyzer 3.0】
http://www.oschina.net/news/2660
Lucene的IK分詞器早在2012年已經沒有維護了，如今咱們要使用的是在其基礎上維護升級的版本，而且開發爲Elasticsearch的集成插件了，與Elasticsearch一塊兒維護升級，版本也保持一致，最新版本：6.2.4
1.5.1. 下載
源碼下載地址：https://github.com/medcl/elasticsearch-analysis-ik/tree/6.2.x
jar包下載地址：https://github.com/medcl/elasticsearch-analysis-ik/releases
1.5.1.安裝
無需安裝，解壓便可使用
咱們將其更名爲ik，並複製到elasticsearch的解壓目錄，以下圖所示
而後重啓elasticsearch：
1.5.2.擴展詞和停用詞
擴展詞和停用詞文件：
###1.5.4 測試
2.SprignBoot整合Spring Data Elasticsearch
Elasticsearch提供的Java客戶端有一些不太方便的地方：
不少地方須要拼接Json字符串，在java中拼接字符串有多恐怖你應該懂的
須要本身把對象序列化爲json存儲
查詢到結果也須要本身反序列化爲對象
所以，咱們這裏就不講解原生的Elasticsearch客戶端API了。
而是學習Spring提供的套件：Spring Data Elasticsearch
2.1.簡介
Spring Data Elasticsearch是Spring Data項目下的一個子模塊。
查看 Spring Data的官網：http://projects.spring.io/spring-data/
Spring Data 是的使命是給各類數據訪問提供統一的編程接口，無論是關係型數據庫（如MySQL），仍是非關係數據庫（如Redis），或者相似Elasticsearch這樣的索引數據庫。從而簡化開發人員的代碼，提升開發效率。
包含不少不一樣數據操做的模塊：
Spring Data Elasticsearch的頁面：https://projects.spring.io/spring-data-elasticsearch/
特徵：
支持Spring的基於@Configuration的java配置方式，或者XML配置方式
提供了用於操做ES的便捷工具類**ElasticsearchTemplate**。包括實現文檔到POJO之間的自動智能映射。
利用Spring的數據轉換服務實現的功能豐富的對象映射
基於註解的元數據映射方式，並且可擴展以支持更多不一樣的數據格式
根據持久層接口自動生成對應實現方法，無需人工編寫基本操做代碼（相似mybatis，根據接口自動獲得實現）。固然，也支持人工定製查詢
2.2.建立Demo工程
咱們新建一個demo，學習Elasticsearch
pom依賴：
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
<modelVersion>4.0.0</modelVersion>
<groupId>com.czxy</groupId>
<artifactId>bos-es</artifactId>
<version>0.0.1-SNAPSHOT</version>
<packaging>jar</packaging>
<name>bos-es</name>
<description>Demo project for Spring Boot</description>
<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.0.4.RELEASE</version>
<relativePath/> <!-- lookup parent from repository -->
</parent>
<properties>
<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
<java.version>1.8</java.version>
</properties>
<dependencies>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-data-elasticsearch</artifactId>
</dependency>
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
<build>
<plugins>
<plugin>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-maven-plugin</artifactId>
</plugin>
</plugins>
</build>
</project>
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
application.properties文件配置：
spring.data.elasticsearch.repositories.enabled = true
spring.data.elasticsearch.cluster-nodes =127.0.0.1:9300
1
2
2.3.索引操做
2.3.1.建立索引和映射
SpringBoot-data-elasticsearch提供了面向對象的方式操做elasticsearch
業務：建立一個商品對象，有這些屬性：
答：id，title，category，brand，price，圖片地址
在SpringDataElasticSearch中，只須要操做對象，就能夠操做elasticsearch中的數據
1
2
3
實體類
首先咱們準備好實體類：
public class Item {
private Long id;
private String title; //標題
private String category;// 分類
private String brand; // 品牌
private Double price; // 價格
private String images; // 圖片地址
}
1
2
3
4
5
6
7
8
映射—註解
Spring Data經過註解來聲明字段的映射屬性，有下面的三個註解：
@Document 做用在類，標記實體類爲文檔對象，通常有兩個屬性
indexName：對應索引庫名稱
type：對應在索引庫中的類型
shards：分片數量，默認5
replicas：副本數量，默認1
@Id 做用在成員變量，標記一個字段做爲id主鍵
@Field 做用在成員變量，標記爲文檔的字段，並指定字段映射屬性：
type：字段類型，是是枚舉：FieldType，能夠是text、long、short、date、integer、object等
text：存儲數據時候，會自動分詞，並生成索引
keyword：存儲數據時候，不會分詞創建索引
Numerical：數值類型，分兩類
基本數據類型：long、interger、short、byte、double、float、half_float
浮點數的高精度類型：scaled_float
須要指定一個精度因子，好比10或100。elasticsearch會把真實值乘以這個因子後存儲，取出時再還原。
Date：日期類型
elasticsearch能夠對日期格式化爲字符串存儲，可是建議咱們存儲爲毫秒值，存儲爲long，節省空間。
index：是否索引，布爾類型，默認是true
store：是否存儲，布爾類型，默認是false
analyzer：分詞器名稱，這裏的ik_max_word即便用ik分詞器
示例：
@Document(indexName = "item",type = "docs", shards = 1, replicas = 0)
public class Item {
@Id
private Long id;
@Field(type = FieldType.Text, analyzer = "ik_max_word")
private String title; //標題
@Field(type = FieldType.Keyword)
private String category;// 分類
@Field(type = FieldType.Keyword)
private String brand; // 品牌
@Field(type = FieldType.Double)
private Double price; // 價格
@Field(index = false, type = FieldType.Keyword)
private String images; // 圖片地址
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
建立索引
ElasticsearchTemplate中提供了建立索引的API：
能夠根據類的信息自動生成，也能夠手動指定indexName和Settings
映射
映射相關的API：
同樣，能夠根據類的字節碼信息（註解配置）來生成映射，或者手動編寫映射
咱們這裏採用類的字節碼信息建立索引並映射：
@Test
public void createIndex() {
// 建立索引，會根據Item類的@Document註解信息來建立
esTemplate.createIndex(Item.class);
// 配置映射，會根據Item類中的id、Field等字段來自動完成映射
esTemplate.putMapping(Item.class);
}
1
2
3
4
5
6
7
索引信息：
2.3.2.刪除索引
刪除索引的API：
能夠根據類名或索引名刪除。
示例：
@Test
public void deleteIndex() {
esTemplate.deleteIndex(Item.class);
// 根據索引名字刪除
//esTemplate.deleteIndex("item1");
}
1
2
3
4
5
6
結果：OK
2.4.新增文檔數據
2.4.1.Repository接口
Spring Data 的強大之處，就在於你不用寫任何DAO處理，自動根據方法名或類的信息進行CRUD操做。只要你定義一個接口，而後繼承Repository提供的一些子接口，就能具有各類基本的CRUD功能。
來看下Repository的繼承關係：
咱們看到有一個ElasticsearchCrudRepository接口：
因此，咱們只須要定義接口，而後繼承它就OK了。
public interface ItemRepository extends ElasticsearchRepository<Item,Long> {
}
1
2
接下來，咱們測試新增數據：
2.4.2.新增一個對象
@Autowired
private ItemRepository itemRepository;
@Test
public void index() {
Item item = new Item(1L, "小米手機7", " 手機",
"小米", 3499.00, "http://image.baidu.com/13123.jpg");
itemRepository.save(item);
}
1
2
3
4
5
6
7
8
9
去頁面查詢看看：
2.4.3.批量新增
代碼：
@Test
public void indexList() {
List<Item> list = new ArrayList<>();
list.add(new Item(2L, "堅果手機R1", " 手機", "錘子", 3699.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(3L, "華爲META10", " 手機", "華爲", 4499.00, "http://image.baidu.com/13123.jpg"));
// 接收對象集合，實現批量新增
itemRepository.saveAll(list);
}
1
2
3
4
5
6
7
8
再次去頁面查詢：
2.4.4.修改
elasticsearch中本沒有修改，它的是該是先刪除在新增
修改和新增是同一個接口，區分的依據就是id。
@Test
public void index(){
Item item = new Item(1L, "蘋果XSMax", " 手機",
"小米", 3499.00, "http://image.baidu.com/13123.jpg");
itemRepository.save(item);
}
1
2
3
4
5
6
查看結果：
2.5.查詢
2.5.1.基本查詢
ElasticsearchRepository提供了一些基本的查詢方法：
咱們來試試查詢全部：
@Test
public void testQueryAll(){
// 查找全部
//Iterable<Item> list = this.itemRepository.findAll();
// 對某字段排序查找全部 Sort.by("price").descending() 降序
// Sort.by("price").ascending():升序
Iterable<Item> list = this.itemRepository.findAll(Sort.by("price").ascending());
for (Item item:list){
System.out.println(item);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
結果：
2.5.2.自定義方法
Spring Data 的另外一個強大功能，是根據方法名稱自動實現功能。
好比：你的方法名叫作：findByTitle，那麼它就知道你是根據title查詢，而後自動幫你完成，無需寫實現類。
固然，方法名稱要符合必定的約定：
Keyword Sample
And findByNameAndPrice
Or findByNameOrPrice
Is findByName
Not findByNameNot
Between findByPriceBetween
LessThanEqual findByPriceLessThan
GreaterThanEqual findByPriceGreaterThan
Before findByPriceBefore
After findByPriceAfter
Like findByNameLike
StartingWith findByNameStartingWith
EndingWith findByNameEndingWith
Contains/Containing findByNameContaining
In findByNameIn(Collection<String>names)
NotIn findByNameNotIn(Collection<String>names)
Near findByStoreNear
True findByAvailableTrue
False findByAvailableFalse
OrderBy findByAvailableTrueOrderByNameDesc
例如，咱們來按照價格區間查詢，定義這樣的一個方法：
public interface ItemRepository extends ElasticsearchRepository<Item,Long> {
/**
* 根據價格區間查詢
* @param price1
* @param price2
* @return
*/
List<Item> findByPriceBetween(double price1, double price2);
}
1
2
3
4
5
6
7
8
9
10
而後添加一些測試數據：
@Test
public void indexList() {
List<Item> list = new ArrayList<>();
list.add(new Item(1L, "小米手機7", "手機", "小米", 3299.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(2L, "堅果手機R1", "手機", "錘子", 3699.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(3L, "華爲META10", "手機", "華爲", 4499.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(4L, "小米Mix2S", "手機", "小米", 4299.00, "http://image.baidu.com/13123.jpg"));
list.add(new Item(5L, "榮耀V10", "手機", "華爲", 2799.00, "http://image.baidu.com/13123.jpg"));
// 接收對象集合，實現批量新增
itemRepository.saveAll(list);
}
1
2
3
4
5
6
7
8
9
10
11
不須要寫實現類，而後咱們直接去運行：
@Test
public void queryByPriceBetween(){
List<Item> list = this.itemRepository.findByPriceBetween(2000.00, 3500.00);
for (Item item : list) {
System.out.println("item = " + item);
}
}
1
2
3
4
5
6
7
結果：
2.5.3.自定義查詢
先來看最基本的match query：
@Test
public void search(){
// 構建查詢條件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 添加基本分詞查詢
queryBuilder.withQuery(QueryBuilders.matchQuery("title", "小米手機"));
// 搜索，獲取結果
Page<Item> items = this.itemRepository.search(queryBuilder.build());
// 總條數
long total = items.getTotalElements();
System.out.println("total = " + total);
for (Item item : items) {
System.out.println(item);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
NativeSearchQueryBuilder：Spring提供的一個查詢條件構建器，幫助構建json格式的請求體
QueryBuilders.matchQuery(「title」, 「小米手機」)：利用QueryBuilders來生成一個查詢。QueryBuilders提供了大量的靜態方法，用於生成各類不一樣類型的查詢：
Page<item>：默認是分頁查詢，所以返回的是一個分頁的結果對象，包含屬性：
totalElements：總條數
totalPages：總頁數
Iterator：迭代器，自己實現了Iterator接口，所以可直接迭代獲得當前頁的數據
其它屬性：
結果：
總的測試代碼：
/**
*
* termQuery
* wildcardQuery
* fuzzyquery
* booleanQuery
* numericRangeQuery
*
*/
@Test
public void testMathQuery(){
// 建立對象
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 在queryBuilder對象中自定義查詢
//matchQuery:底層就是使用的termQuery
queryBuilder.withQuery(QueryBuilders.matchQuery("title","堅果"));
//查詢，search 默認就是分頁查找
Page<Item> page = this.itemRepository.search(queryBuilder.build());
//獲取數據
long totalElements = page.getTotalElements();
System.out.println("獲取的總條數:"+totalElements);
for(Item item:page){
System.out.println(item);
}
}
/**
* termQuery:功能更強大，除了匹配字符串意外，還能夠匹配int/long/double/float/....
*/
@Test
public void testTermQuery(){
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
builder.withQuery(QueryBuilders.termQuery("price",998.0));
// 查找
Page<Item> page = this.itemRepository.search(builder.build());
for(Item item:page){
System.out.println(item);
}
}
@Test
public void testBooleanQuery(){
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
builder.withQuery(
QueryBuilders.boolQuery().must(QueryBuilders.matchQuery("title","華爲"))
.must(QueryBuilders.matchQuery("brand","華爲"))
);
// 查找
Page<Item> page = this.itemRepository.search(builder.build());
for(Item item:page){
System.out.println(item);
}
}
@Test
public void testFuzzyQuery(){
NativeSearchQueryBuilder builder = new NativeSearchQueryBuilder();
builder.withQuery(QueryBuilders.fuzzyQuery("title","faceoooo"));
Page<Item> page = this.itemRepository.search(builder.build());
for(Item item:page){
System.out.println(item);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
2.5.4.分頁查詢
利用NativeSearchQueryBuilder能夠方便的實現分頁：
@Test
public void searchByPage(){
// 構建查詢條件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 添加基本分詞查詢
queryBuilder.withQuery(QueryBuilders.termQuery("category", "手機"));
// 分頁：
int page = 0;
int size = 2;
queryBuilder.withPageable(PageRequest.of(page,size));
// 搜索，獲取結果
Page<Item> items = this.itemRepository.search(queryBuilder.build());
// 總條數
long total = items.getTotalElements();
System.out.println("總條數 = " + total);
// 總頁數
System.out.println("總頁數 = " + items.getTotalPages());
// 當前頁
System.out.println("當前頁：" + items.getNumber());
// 每頁大小
System.out.println("每頁大小：" + items.getSize());
for (Item item : items) {
System.out.println(item);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
結果：
[外鏈圖片轉存失敗(img-4q9Esx9y-1562576542892)(assets/1538083677832.png)]
能夠發現，Elasticsearch中的分頁是從第0頁開始。
2.5.5.排序
排序也通用經過NativeSearchQueryBuilder完成：
@Test
public void searchAndSort(){
// 構建查詢條件
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 添加基本分詞查詢
queryBuilder.withQuery(QueryBuilders.termQuery("category", "手機"));
// 排序
queryBuilder.withSort(SortBuilders.fieldSort("price").order(SortOrder.ASC));
// 搜索，獲取結果
Page<Item> items = this.itemRepository.search(queryBuilder.build());
// 總條數
long total = items.getTotalElements();
System.out.println("總條數 = " + total);
for (Item item : items) {
System.out.println(item);
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
結果：
2.6.聚合（牛逼！！solr無此功能）
聚合可讓咱們極其方便的實現對數據的統計、分析。例如：
什麼品牌的手機最受歡迎？
這些手機的平均價格、最高價格、最低價格？
這些手機每個月的銷售狀況如何？
實現這些統計功能的比數據庫的sql要方便的多，並且查詢速度很是快，能夠實現近實時搜索效果。
2.6.1 基本概念
Elasticsearch中的聚合，包含多種類型，最經常使用的兩種，一個叫桶，一個叫度量：
桶（bucket）
桶的做用，是按照某種方式對數據進行分組，每一組數據在ES中稱爲一個桶，例如咱們根據國籍對人劃分，能夠獲得中國桶、英國桶，日本桶……或者咱們按照年齡段對人進行劃分：010,1020,2030,3040等。
Elasticsearch中提供的劃分桶的方式有不少：
Date Histogram Aggregation：根據日期階梯分組，例如給定階梯爲周，會自動每週分爲一組
Histogram Aggregation：根據數值階梯分組，與日期相似
Terms Aggregation：根據詞條內容分組，詞條內容徹底匹配的爲一組
Range Aggregation：數值和日期的範圍分組，指定開始和結束，而後按段分組
……
綜上所述，咱們發現bucket aggregations 只負責對數據進行分組，並不進行計算，所以每每bucket中每每會嵌套另外一種聚合：metrics aggregations即度量
度量（metrics）
分組完成之後，咱們通常會對組中的數據進行聚合運算，例如求平均值、最大、最小、求和等，這些在ES中稱爲度量
比較經常使用的一些度量聚合方式：
Avg Aggregation：求平均值
Max Aggregation：求最大值
Min Aggregation：求最小值
Percentiles Aggregation：求百分比
Stats Aggregation：同時返回avg、max、min、sum、count等
Sum Aggregation：求和
Top hits Aggregation：求前幾
Value Count Aggregation：求總數
……
注意：在ES中，須要進行聚合、排序、過濾的字段其處理方式比較特殊，所以不能被分詞。這裏咱們將color和make這兩個文字類型的字段設置爲keyword類型，這個類型不會被分詞，未來就能夠參與聚合
2.6.2.聚合爲桶
桶就是分組，好比這裏咱們按照品牌brand進行分組：
@Test
public void testAgg(){
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 不查詢任何結果
queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
// 一、添加一個新的聚合，聚合類型爲terms，聚合名稱爲brands，聚合字段爲brand
queryBuilder.addAggregation(
AggregationBuilders.terms("brands").field("brand"));
// 二、查詢,須要把結果強轉爲AggregatedPage類型
AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
// 三、解析
// 3.一、從結果中取出名爲brands的那個聚合，
// 由於是利用String類型字段來進行的term聚合，因此結果要強轉爲StringTerm類型
StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
// 3.二、獲取桶
List<StringTerms.Bucket> buckets = agg.getBuckets();
// 3.三、遍歷
for (StringTerms.Bucket bucket : buckets) {
// 3.四、獲取桶中的key，即品牌名稱
System.out.println(bucket.getKeyAsString());
// 3.五、獲取桶中的文檔數量
System.out.println(bucket.getDocCount());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
顯示的結果：
關鍵API：
AggregationBuilders：聚合的構建工廠類。全部聚合都由這個類來構建，看看他的靜態方法：
（1）統計某個字段的數量
ValueCountBuilder vcb= AggregationBuilders.count("count_uid").field("uid");
（2）去重統計某個字段的數量（有少許偏差）
CardinalityBuilder cb= AggregationBuilders.cardinality("distinct_count_uid").field("uid");
（3）聚合過濾
FilterAggregationBuilder fab= AggregationBuilders.filter("uid_filter").filter(QueryBuilders.queryStringQuery("uid:001"));
（4）按某個字段分組
TermsBuilder tb= AggregationBuilders.terms("group_name").field("name");
（5）求和
SumBuilder sumBuilder= AggregationBuilders.sum("sum_price").field("price");
（6）求平均
AvgBuilder ab= AggregationBuilders.avg("avg_price").field("price");
（7）求最大值
MaxBuilder mb= AggregationBuilders.max("max_price").field("price");
（8）求最小值
MinBuilder min= AggregationBuilders.min("min_price").field("price");
（9）按日期間隔分組
DateHistogramBuilder dhb= AggregationBuilders.dateHistogram("dh").field("date");
（10）獲取聚合裏面的結果
TopHitsBuilder thb= AggregationBuilders.topHits("top_result");
（11）嵌套的聚合
NestedBuilder nb= AggregationBuilders.nested("negsted_path").path("quests");
（12）反轉嵌套
AggregationBuilders.reverseNested("res_negsted").path("kps ");
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
AggregatedPage：聚合查詢的結果類。它是Page<T>的子接口：
AggregatedPage在Page功能的基礎上，拓展了與聚合相關的功能，它其實就是對聚合結果的一種封裝。
而返回的結果都是Aggregation類型對象，不過根據字段類型不一樣，又有不一樣的子類表示
2.6.2.嵌套聚合，求平均值
代碼：
@Test
public void testSubAgg(){
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
// 不查詢任何結果
queryBuilder.withSourceFilter(new FetchSourceFilter(new String[]{""}, null));
// 一、添加一個新的聚合，聚合類型爲terms，聚合名稱爲brands，聚合字段爲brand
queryBuilder.addAggregation(
AggregationBuilders.terms("brands").field("brand")
.subAggregation(AggregationBuilders.avg("priceAvg").field("price")) // 在品牌聚合桶內進行嵌套聚合，求平均值
);
// 二、查詢,須要把結果強轉爲AggregatedPage類型
AggregatedPage<Item> aggPage = (AggregatedPage<Item>) this.itemRepository.search(queryBuilder.build());
// 三、解析
// 3.一、從結果中取出名爲brands的那個聚合，
// 由於是利用String類型字段來進行的term聚合，因此結果要強轉爲StringTerm類型
StringTerms agg = (StringTerms) aggPage.getAggregation("brands");
// 3.二、獲取桶
List<StringTerms.Bucket> buckets = agg.getBuckets();
// 3.三、遍歷
for (StringTerms.Bucket bucket : buckets) {
// 3.四、獲取桶中的key，即品牌名稱 3.五、獲取桶中的文檔數量
System.out.println(bucket.getKeyAsString() + "，共" + bucket.getDocCount() + "臺");
// 3.6.獲取子聚合結果：
InternalAvg avg = (InternalAvg) bucket.getAggregations().asMap().get("priceAvg");
System.out.println("平均售價：" + avg.getValue());
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
結果：
2.7.基本概念
Elasticsearch也是基於Lucene的全文檢索庫，本質也是存儲數據，不少概念與MySQL相似的。
對比關係：
索引庫（indices）--------------------------------Databases 數據庫
類型（type）-----------------------------Table 數據表
文檔（Document）----------------Row 行
字段（Field）-------------------Columns 列
1
2
3
4
5
詳細說明：
概念 說明
索引庫（indices) indices是index的複數，表明許多的索引，
類型（type） 類型是模擬mysql中的table概念，一個索引庫下能夠有不一樣類型的索引，好比商品索引，訂單索引，其數據格式不一樣。不過這會致使索引庫混亂，所以將來版本中會移除這個概念
文檔（document） 存入索引庫原始的數據。好比每一條商品信息，就是一個文檔
字段（field） 文檔中的屬性
映射配置（mappings） 字段的數據類型、屬性、是否索引、是否存儲等特性
是否是與Lucene中的概念相似。
另外，在Elasticsearch有一些集羣相關的概念：
索引集（Indices，index的複數）：邏輯上的完整索引
分片（shard）：數據拆分後的各個部分
副本（replica）：每一個分片的複製
要注意的是：Elasticsearch自己就是分佈式的，所以即使你只有一個節點，Elasticsearch默認也會對你的數據進行分片和副本操做，當你向集羣添加新數據時，數據也會在新加入的節點中進行平衡。
##2.8bug1：Must be in the format host:port!
(一個綜合查詢方法)
@Override
public DatagridResult conditionQuery(WayBill wayBill, Integer page, Integer rows) {
NativeSearchQueryBuilder queryBuilder = new NativeSearchQueryBuilder();
BoolQueryBuilder boolQuery = QueryBuilders.boolQuery();
//判斷訂單號
if (StringUtils.isNotBlank(wayBill.getWayBillNum())){
WildcardQueryBuilder wayBillNum = QueryBuilders.wildcardQuery("wayBillNum", "*" + wayBill.getWayBillNum() + "*");
boolQuery.must(wayBillNum);
}
// 2 發貨地 分詞
if (StringUtils.isNotBlank(wayBill.getSendAddress())){
// 2 改進的第一個問題：北京市順義區 北 京 市 北京 順義 義區 這種方式容許查嗎？
WildcardQueryBuilder sendAddressequeryBuilder1 = QueryBuilders.wildcardQuery("sendAddress", "*" + wayBill.getSendAddress() + "*");
// 3 改進的第二個問題：北京順義 這種方式要被容許-->這種方式須要對 查詢詞條進行分詞後 再進行查詢
// QueryStringQueryBuilder此對象會對查詢的詞條分詞後的各類狀況進行分詞查找
// 參數：就是前臺傳過來的查詢內容
// QueryStringQueryBuilder queryStringQueryBuilder = new QueryStringQueryBuilder(wayBill.getSendAddress());
// queryStringQueryBuilder.field("sendAddress").defaultOperator(Operator.AND);
QueryStringQueryBuilder queryStringQueryBuilder = new QueryStringQueryBuilder(wayBill.getSendAddress()).field("sendAddress").defaultOperator(Operator.AND);
BoolQueryBuilder should = QueryBuilders.boolQuery().should(sendAddressequeryBuilder1).should(queryStringQueryBuilder);
boolQuery.must(should);
}
//收貨地址
if (StringUtils.isNotBlank(wayBill.getRecAddress())){
WildcardQueryBuilder recAddressQuery = QueryBuilders.wildcardQuery("recAddress", "*" + wayBill.getRecAddress() + "*");
//改進 容許對詞條分詞後 在查詢
QueryStringQueryBuilder recAddressQueryString = new QueryStringQueryBuilder(wayBill.getRecAddress()).field("recAddress").defaultOperator(Operator.AND);
//取並集
BoolQueryBuilder should = QueryBuilders.boolQuery().should(recAddressQuery).should(recAddressQueryString);
boolQuery.must(should);
}
//4 速運當日、速運第二天、速運隔日 sds
if (StringUtils.isNotBlank(wayBill.getSendProNum())){
TermQueryBuilder sendProNumQuery = QueryBuilders.termQuery("sendProNum", wayBill.getSendProNum());
boolQuery.must(sendProNumQuery);
}
//5 運單狀態： 1 待發貨、 2 派送中、3 已簽收、4 異常
if (wayBill.getSignStatus()!=null&& wayBill.getSignStatus()!=0){
TermQueryBuilder signStatus = QueryBuilders.termQuery("signStatus", wayBill.getSignStatus());
boolQuery.must(signStatus);
}
// 執行分頁
queryBuilder.withPageable(PageRequest.of(page-1,rows));
// 執行查詢
queryBuilder.withQuery(boolQuery);
Page<ESWayBill> list = wayBillRepository.search(queryBuilder.build());
//拼接結果
DatagridResult result = new DatagridResult();
result.setTotal(list.getTotalElements());
result.setRows(list.getContent());
return result;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
扶貧！！ 幫助一下孩子吧。感謝♥：
--------------------- 版權聲明：本文爲CSDN博主「maojunfang」的原創文章，遵循CC 4.0 by-sa版權協議，轉載請附上原文出處連接及本聲明。原文連接：https://blog.csdn.net/weixin_42633131/article/details/82902812