elasticsearch RestHighLevelClient 使用方法及封裝工具
目錄html
git地址：https://gitee.com/zxporz/ESClientRHL前端
EsClientRHL
EsClientRHL是一個可基於springboot的elasticsearch RestHighLevelClient客戶端調用封裝工具，主要提供了es索引結構工具、es索引數據增刪改工具、es查詢工具、es數據分析工具。java
基於elasticsearch6.6+版本進行開發，因爲採用RestHighLevelClient，因此版本兼容問題應該能獲得必定改善。react
更新日誌
| 更新日期 | 更新內容 |
|---|---|
| 2019-03-19 | 修復了一個搜索建議mapping的bug，增長了按照條件刪除的api、添加了檢索時能夠檢索多個索引的api以及註解配置方式（詳見api更新） |
| 2019-04-16 | 優化了@EnableESTools獲取entity地址的邏輯，並添加了esclientrhl-start的支持，增長ImportBeanDefinitionRegistrar（彩蛋） |
開發緣由：
- 目前spring-data-elasticsearch底層採用es官方TransportClient，而es官方計劃放棄TransportClient，工具以es官方推薦的RestHighLevelClient進行封裝
- 可以從java與es交互的常見方面極大簡化API，並不斷更新，讓es更高級的功能更輕鬆的使用
使用前你應該具備哪些技能
- springboot
- maven
- elasticsearch基礎概念
- elasticsearch rest api含義以及用法
工具功能範圍介紹
索引結構管理
- 判斷索引是否存在
- 索引結構建立
- 自動定製索引結構mapping
刪除索引結構git
CRUD
- LowLevelClient查詢
- 新增索引數據
- 批量新增索引數據
- 覆蓋更新索引數據
- 部分更新索引數據
- 刪除索引數據
- 判斷索引數據是否存在
- 原生查詢
- 支持、查詢條件的定製查詢
- 支持分頁、高亮、排序、查詢條件的定製查詢
- count查詢
- scroll查詢（用於大數據量查詢）
模版查詢- 搜索建議
- 根據ID查詢
- mget查詢
按照多索引查詢說明（2013-03-19新增）正則表達式
聚合查詢
- 原生聚合查詢
- 普通聚合查詢
- 分組普通聚合查詢
- 下鑽（2層）聚合查詢
- 統計聚合查詢
- 分組統計聚合查詢
- 基數查詢
- 百分比聚合查詢
- 百分等級聚合查詢
- 過濾器聚合查詢
- 直方圖聚合查詢
日期直方圖聚合查詢spring
工具源碼結構介紹
annotation
存放一些註解，用於簡化組件使用sql
config
基於springboot的自動化的功能，包括自動配置es客戶端組件以及自動管理索引結構的功能json
enums
基礎數據的枚舉後端
index
索引結構管理的功能包
repository
CURD+聚合的功能包
util
內部工具包
開始使用
使用前說明
- 組件基於JDK1.8編譯，請注意JDK版本的選擇
- 目前只支持springboot方式集成，若是須要與普通spring系統集成須要作簡單改造
maven依賴
請把組件安裝到maven倉庫
<dependency>
<groupId>org.zxp</groupId>
<artifactId>esclientrhl</artifactId>
<version>1.0.0</version>
</dependency>
也能夠直接引入starter
請下載esclientrhl-springboot-starter
<dependency>
<groupId>org.zxp</groupId>
<artifactId>esclientrhl-springboot-starter</artifactId>
<version>1.0.0</version>
</dependency>
如何集成springboot項目後出現elasticsearch底層版本問題，請在springboot工程中設定es版本號
<dependency>
<groupId>org.elasticsearch</groupId>
<artifactId>elasticsearch</artifactId>
<version>6.6.0</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>6.6.0</version>
</dependency>
引入組件
在springboot啓動類上添加
@SpringBootApplication
@EnableESTools
public class EsdemoApplication {
public static void main(String[] args) {
SpringApplication.run(EsdemoApplication.class, args);
}
}
若是引入的是esclientrhl-starter，則啓動類上無需添加@EnableESTools，會自動掃描啓動類路徑下的包，除非有額外的包須要配置，不然無需配置@EnableESTools application.properties配置elasticsearch服務的uri，若是有多個（集羣狀況）請用半角逗號```,```隔開
elasticsearch.host=127.0.0.1:9200
#### 使用組件 在spring管理的bean內直接自動注入組件內置的兩個工具服務：```ElasticsearchTemplate、ElasticsearchIndex```並調用相關api便可
@Service
public class CompletionSuggestServiceImpl implements CompletionSuggestService {
@Autowired
ElasticsearchTemplate<Book,String> elasticsearchTemplate;
#### 索引管理功能 ###### 元數據配置 用於定製es索引結構對應實體類的元數據
@ESMetaData(indexName = "index",indexType = "main4", number_of_shards = 5,number_of_replicas = 0)
包含的主要配置信息以及默認值以下
/**
- 檢索時的索引名稱，若是不配置則默認爲和indexName一致，該註解項僅支持搜索
- 並不建議這麼作，建議經過特定方法來作跨索引查詢
*/
String[] searchIndexNames() default {};
/** - 索引名稱，必須配置
*/
String indexName();
/** - 索引類型，必須配置，牆裂建議每一個index下只有一個type
*/
String indexType();
/** - 主分片數量
*/
int number_of_shards() default 5;
/** - 備份分片數量
*/
int number_of_replicas() default 1;
/** - 是否打印日誌
- @return
*/
boolean printLog() default false;
###### 索引結構配置 用於定製es索引結構對應實體類的索引結構，以簡化建立索引工做。將相關注解配置於實體類field上，用於標識field對應elasticsearch索引結構字段的相關信息
@ESID
private String proposal_no;
@ESMapping(datatype = DataType.keyword_type)
private String risk_code;
@ESMapping(datatype = DataType.text_type)
private String risk_name;
@ESID標識es主鍵（自動對應es索引數據_id字段），注意：主鍵的類型須要與ElasticsearchTemplate```的第二泛型一致
/**
- 數據類型（包含 關鍵字類型）
*/
DataType datatype() default DataType.text_type;
/** - 間接關鍵字
*/
boolean keyword() default true;
/** - 關鍵字忽略字數
*/
int ignore_above() default 256;
/** - 是否支持autocomplete，高效全文搜索提示（定製gram分詞器，請參照官方例https://www.elastic.co/guide/en/elasticsearch/reference/7.x/analysis-ngram-tokenizer.html）
*/
boolean autocomplete() default false;
/** - 是否支持suggest，高效前綴搜索提示
*/
boolean suggest() default false;
/** - 索引分詞器設置（研究類型）
*/
Analyzer analyzer() default Analyzer.standard;
/** - 搜索內容分詞器設置
*/
Analyzer search_analyzer() default Analyzer.standard;
/** - 是否容許被搜索
*/
boolean allow_search() default true;
/**
- 拷貝到哪一個字段，代替_all
*/
String copy_to() default "";
若是對字段類型要求沒有那麼高，則不配置，組件能夠支持自動適配mapping ###### 根據配置信息自動建立索引結構mapping 項目啓動時，組件會自動識別es實體類上配置的```@ESMetaData```註解，若是對應的索引結構沒有建立，自動根據mapping註解配置建立相關索引結構。 若是實體類不在啓動類的包路徑下，如需啓用此功能，須要在啓動註解上配置實體類路徑。
@EnableESTools(entityPath = "com.*.esdemo.domain")
###### 手工建立或刪除索引結構
elasticsearchIndex.dropIndex(Main2.class);
elasticsearchIndex.createIndex(Main2.class);
###### 判斷索引是否存在
/**
- 索引是否存在
- @param clazz傳入es索引結構對應實體類
- @throws Exception
*/
public boolean exists(Classclazz) throws Exception;
elasticsearchIndex.exists(Main2.class)
#### CRUD功能說明 ###### LowLevelClient查詢 這種狀況一般適用於直接發JSON報文查詢或操做es服務端，本方法並無作太多的封裝，基本保留了原生的出入參
//自動注入工具類
@Autowired
ElasticsearchTemplate elasticsearchTemplate;
//執行查詢
Request request = new Request("GET","/esdemo");
request.setEntity(new NStringEntity("{"query":{"match_all":{"boost":1.0}}}",ContentType.APPLICATION_JSON));
Response response = elasticsearchTemplate.request(request);
RequestLine requestLine = response.getRequestLine();
HttpHost host = response.getHost();
int statusCode = response.getStatusLine().getStatusCode();
Header[] headers = response.getHeaders();
String responseBody = EntityUtils.toString(response.getEntity());
System.out.println(responseBody);
###### 新增索引數據 如無特殊說明下面查詢都默認注入了工具類，工具類第一泛型是要操做的es索引結構的類，第二泛型是索引對應主鍵的類
@Autowired
ElasticsearchTemplate<Main2,String> elasticsearchTemplate;
Main2類型的主鍵是String
@ESMetaData(indexName = "index",indexType = "main", number_of_shards = 5,number_of_replicas = 0)
public class Main2 implements Serializable {
private static final long serialVersionUID = 1L;
@ESID
private String proposal_no;
Main2 main = new Main2();
main.setProposal_no("main2");
main.setAppli_code("123");
main.setAppli_name("456");
elasticsearchTemplate.save(main);
###### 批量新增索引數據
List
Main2 main1 = new Main2();
main1.setProposal_no("main1");
main1.setAppli_code("123");
main1.setAppli_name("456");
Main2 main2 = new Main2();
main2.setProposal_no("main2");
main2.setAppli_code("123");
main2.setAppli_name("456");
Main2 main3 = new Main2();
main3.setProposal_no("main3");
main3.setAppli_code("123");
main3.setAppli_name("456");
list.add(main1);
list.add(main2);
list.add(main3);
elasticsearchTemplate.save(list);
###### 部分更新索引數據
Main2 main1 = new Main2();
main1.setProposal_no("main1");
main1.setInsured_code("123");
elasticsearchTemplate.update(main1);
###### 覆蓋更新索引數據
Main2 main1 = new Main2();
main1.setProposal_no("main1");
main1.setInsured_code("123");
elasticsearchTemplate.updateCover(main1);
部分更新相比於覆蓋更新的區別是，部分更新只會更新set了的字段值 ###### 刪除索引數據
//經過對象刪除，ID必須有值
Main2 main1 = new Main2();
main1.setProposal_no("main1");
main1.setInsured_code("123");
elasticsearchTemplate.delete(main1);
//經過ID刪除
elasticsearchTemplate.deleteById("main1",Main2.class);
###### 根據查詢條件刪除索引數據
elasticsearchTemplate.deleteByCondition(QueryBuilders.matchQuery("appli_name","2"),Main5.class);
###### 判斷索引數據是否存在
Main2 main1 = new Main2();
main1.setProposal_no("main1");
main1.setInsured_code("123");
boolean exists = elasticsearchTemplate.exists("main1",Main2.class);
System.out.println(exists);
###### 原生查詢 searchRequest是官方原生查詢輸入，此方法在工具沒法知足需求時使用
SearchRequest searchRequest = new SearchRequest(new String[]{"index"});
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(new MatchAllQueryBuilder());
searchSourceBuilder.from(0);
searchSourceBuilder.size(10);
searchRequest.source(searchSourceBuilder);
SearchResponse searchResponse = elasticsearchTemplate.search(searchRequest);
SearchHits hits = searchResponse.getHits();
SearchHit[] searchHits = hits.getHits();
for (SearchHit hit : searchHits) {
Main2 t = JsonUtils.string2Obj(hit.getSourceAsString(), Main2.class);
System.out.println(t);
}
###### 支持、查詢條件的定製查詢
/**
- 非分頁查詢
- 目前暫時傳入類類型
- @param queryBuilder 查詢條件
- @param clazz 泛型對應類類型
- @return 泛型定義好的es索引結構實體類查詢結果集合
- @throws Exception
*/
public Listsearch(QueryBuilder queryBuilder, Class clazz) throws Exception;
//這裏簡單經過matchall（全查詢）的方式進行演示
//QueryBuilder的用法會在單獨章節介紹
List
main2List.forEach(main2 -> System.out.println(main2));
###### 支持分頁、高亮、排序、查詢條件的定製查詢
/**
- 支持分頁、高亮、排序的查詢
- @param queryBuilder 查詢條件
- @param pageSortHighLight 封裝了分頁、排序、高亮的規格信息
- @param clazz 泛型對應類類型
- @return 泛型定義好的es索引結構實體類查詢結果集合
- @throws Exception
*/
public PageListsearch(QueryBuilder queryBuilder, PageSortHighLight pageSortHighLight, Class clazz) throws Exception;
//定製分頁信息
int currentPage = 1;
int pageSize = 10;
//分頁
PageSortHighLight psh = new PageSortHighLight(currentPage,pageSize);
//排序字段，注意若是proposal_no是text類型會默認帶有keyword性質，須要拼接.keyword
String sorter = "proposal_no.keyword";
Sort.Order order = new Sort.Order(SortOrder.ASC,sorter);
psh.setSort(new Sort(order));
//定製高亮，若是定製了高亮，返回結果會自動替換字段值爲高亮內容
psh.setHighLight(new HighLight().field("risk_code"));
//能夠單獨定義高亮的格式
//new HighLight().setPreTag("");
//new HighLight().setPostTag("");
PageList
pageList = elasticsearchTemplate.search(new MatchAllQueryBuilder(), psh, Main2.class);
pageList.getList().forEach(main2 -> System.out.println(main2));
###### count查詢 結合查詢條件查詢結果的數據量
long count = elasticsearchTemplate.count(new MatchAllQueryBuilder(),Main2.class);
System.out.println(count);
###### scroll查詢
/**
- scroll方式查詢，用於大數據量查詢
- @param queryBuilder 查詢條件
- @param clazz 類類型
- @param time 保留小時數
- @return
- @throws Exception
*/
public Listscroll(QueryBuilder queryBuilder, Class clazz, long time) throws Exception;
/**
- scroll方式查詢，用於大數據量查詢，默認了保留時間爲2小時(Constant.DEFAULT_SCROLL_TIME)
- @param queryBuilder
- @param clazz
- @return
- @throws Exception
*/
public Listscroll(QueryBuilder queryBuilder, Class clazz) throws Exception;
//默認scroll鏡像保留2小時
List
main2List.forEach(main2 -> System.out.println(main2));
//指定scroll鏡像保留5小時
//List
###### ~~模版查詢~~ 暫時沒法使用該方法，緣由爲官方API SearchTemplateRequestBuilder仍保留對transportClient 的依賴，但Migration Guide 中描述須要把transportClient遷移爲RestHighLevelClient ###### 搜索建議 搜索建議功能可以快速提示要搜索的內容（請參考百度搜索功能），搜索建議字段須要配置suggest屬性爲true
/**
- 搜索建議方法
- @param fieldName 要搜索的字段（須要設置該字段mapping配置suggest屬性爲true）
- @param fieldValue 要搜索的內容
- @param clazz
- @return 返回搜索結果列表 搜索建議默認條數爲10條
- @throws Exception
*/
public ListcompletionSuggest(String fieldName,String fieldValue,Class clazz) throws Exception;
List
list.forEach(main2 -> System.out.println(main2));
@ESMapping(suggest = true)
private String appli_name;
###### 根據ID查詢
/**
- 根據ID查詢
- @param id 主鍵值，對應第二泛型類型
- @param clazz
- @return
- @throws Exception
*/
public T getById(M id, Classclazz) throws Exception;
Main2 main2 = elasticsearchTemplate.getById("main2", Main2.class);
System.out.println(main2);
###### mget查詢
/**
- 根據ID列表批量查詢
- @param ids ID主鍵數組
- @param clazz
- @return
- @throws Exception
*/
public ListmgetById(M[] ids, Class clazz) throws Exception;
String[] list = {"main2","main3"};
List
listResult.forEach(main -> System.out.println(main));
#### QueryBuilder經常使用用法展現 ###### 精準查詢
//精準查詢的字段須要設置keyword屬性（默認該屬性爲true），查詢時fieldname須要帶上.keyword
QueryBuilder queryBuilder = QueryBuilders.termQuery("appli_name.keyword","456");
List
list.forEach(main2 -> System.out.println(main2));
//若是field類型直接爲keyword能夠不用加.keyword
###### 短語查詢
//中國好男兒
//必須相鄰的查詢條件
QueryBuilder queryBuilder = QueryBuilders.matchPhraseQuery("appli_name","國好");
###### 相關度查詢
//中國好男兒
//slop設置爲2，中和男最多能移動兩次並完成匹配
QueryBuilder queryBuilder = QueryBuilders.matchPhraseQuery("appli_name","中男").slop(2);
###### 範圍查詢
QueryBuilder queryBuilder = QueryBuilders.rangeQuery("sum_premium").from(1).to(3);
###### 全文匹配
QueryBuilder queryBuilder = QueryBuilders.matchQuery("appli_name","中男兒");
minimumShouldMatch最少匹配參數
//"中 男 兒 美 麗 人 生"最少匹配詞語數量是75%，該查詢查不到信息
QueryBuilder queryBuilder = QueryBuilders.matchQuery("appli_name","中 男 兒 美 麗 人 生").minimumShouldMatch("75%");
match查詢集成fuzzy糾錯查詢
QueryBuilder queryBuilder = QueryBuilders.matchQuery("appli_name","spting");
((MatchQueryBuilder) queryBuilder).fuzziness(Fuzziness.AUTO);
match查詢設定查詢條件邏輯關係
//默認是OR
QueryBuilder queryBuilder = QueryBuilders.matchQuery("appli_name","spring sps").operator(Operator.AND);
###### fuzzy糾錯查詢
//原文是spring，查詢條件輸入爲spting也能查詢到結果
QueryBuilder queryBuilder = QueryBuilders.fuzzyQuery("appli_name","spting");
###### boost權重設置
//查詢結果appli_name爲spring的會被優先展現其次456，再次123
QueryBuilder queryBuilder1 = QueryBuilders.termQuery("appli_name.keyword","spring").boost(5);
QueryBuilder queryBuilder2 = QueryBuilders.termQuery("appli_name.keyword","456").boost(3);
QueryBuilder queryBuilder3 = QueryBuilders.termQuery("appli_name.keyword","123");
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
queryBuilder.should(queryBuilder1).should(queryBuilder2).should(queryBuilder3);
###### prefix前綴查詢
//性能差，掃描整個倒排索引，前綴越短，要處理的doc越多，性能越差，儘量用長前綴搜索
//查詢appli_name字段值前綴爲1的內容
QueryBuilder queryBuilder = QueryBuilders.prefixQuery("appli_name","1");
###### wildcard通配符查詢
//性能較差不建議使用
//?：任意字符
//*：0個或任意多個字符
QueryBuilder queryBuilder = QueryBuilders.wildcardQuery("appli_name","1?3");
###### regexp正則查詢
//性能較差不建議使用
QueryBuilder queryBuilder = QueryBuilders.regexpQuery("appli_name","[0-9].+");
//[0-9]：指定範圍內的數字
//[a-z]：指定範圍內的字母
//.：一個字符
//+：前面的正則表達式能夠出現一次或屢次
###### 組合邏輯查詢 組合邏輯查詢是多種查詢方式的邏輯組合，共有三種：與must、或should、非mustNot
//select * from Main2 where (appli_name = 'spring' or appli_name = '456') and risk_code = '0101' and proposal_no != '1234567'
QueryBuilder queryBuilder1 = QueryBuilders.termQuery("appli_name.keyword","spring");
QueryBuilder queryBuilder2 = QueryBuilders.termQuery("appli_name.keyword","456");
QueryBuilder queryBuilder3 = QueryBuilders.termQuery("risk_code","0101");
QueryBuilder queryBuilder4 = QueryBuilders.termQuery("proposal_no.keyword","1234567");
BoolQueryBuilder queryBuilder = QueryBuilders.boolQuery();
queryBuilder.should(queryBuilder1).should(queryBuilder2);
queryBuilder.must(queryBuilder3);
queryBuilder.mustNot(queryBuilder4);
###### 過濾器 > 過濾器查詢須要和布爾查詢結合使用，效果上和普通查詢沒有什麼區別 > 好比下面的例子must和filter的關係是而且 > 但過濾器查詢首先不會計算相關度評分，而普通查詢會去計算相關度評分，而且按照相關對進行排序，那麼若是你並不須要相關度評分就要優先選擇過濾器查詢 > 另外過濾器查詢內置了bitset的caching機制，可以很是大程度的提高查詢的性能，減小掃描倒排索引的概率，因此在平常開發中，咱們須要認真評估，積極使用過濾器查詢
//select * from Main2 where appli_name = '456' and risk_code = '0101'
QueryBuilder queryBuilder = QueryBuilders.boolQuery().must(QueryBuilders.termQuery("appli_name.keyword","456"))
//下面若是會比較頻繁的做爲子集合，就比較適合經過filter來緩存
.filter(QueryBuilders.matchPhraseQuery("risk_code","0101"));
List
list.forEach(main2 -> System.out.println(main2));
> 更多QueryBuilder詳見https://www.elastic.co/guide/en/elasticsearch/client/java-rest/6.6/java-rest-high-query-builders.html ###### 按照多索引查詢說明 有兩種方式可供多索引查詢 1. 經過配置註解```searchIndexNames```，這種方式能夠在默認能查詢多索引的全部api中生效，若是配置此項，再相應的查詢方法將會查詢多個索引，並按照當前poji的字段結果進行返回，但因爲經過註解配置不靈活，因此若是不是特別肯定的場景並不建議這麼作。
@ESMetaData(indexName = "main5",indexType = "main5",searchIndexNames = {"main5","index"}, number_of_shards = 5,number_of_replicas = 0,printLog = false)
public class Main5 implements Serializable {
//查詢api調用不發生任何變化
2. 經過api傳入須要查詢的多個索引名稱，這種方式相比註解方式更加靈活可靠，若是涉及跨索引查詢的業務推薦使用這種方法，目前已經添加了普通查詢對應的多索引入參api，後續將添加聚合查詢的跨索引查詢
//傳入main五、main6做爲須要被2個索引範圍
List
System.out.println(list.size());
//查詢結果僅包含main6的字段結果
list.forEach(main6 -> System.out.println(main6));
這是一個新增的接口方法實例，均在最後添加了可變長入參的方式
/**
* 非分頁查詢(跨索引)
* 目前暫時傳入類類型
* @param queryBuilder
* @param clazz
* @return
* @throws Exception
*/
public List
==建議跨索引查詢時多索引之間儘可能字段重合度高== #### 聚合查詢 ###### 原生聚合查詢
/**
- 聚合基礎方法，此方法較少封裝，其目的爲了知足工具沒法實現的聚合查詢
- @param aggregationBuilder 聚合內容
- @param queryBuilder 檢索條件
- @param clazz
- @return 聚合結果（官方原生聚合結果）
- @throws Exception
*/
public Aggregations aggs(AggregationBuilder aggregationBuilder, QueryBuilder queryBuilder, Classclazz) throws Exception;
SumAggregationBuilder aggregation = AggregationBuilders.sum("agg").field("sum_amount");
Aggregations aggregations = elasticsearchTemplate.aggs(aggregation,null,Main2.class);
Sum agg = aggregations.get("agg");
double value = agg.getValue();
System.out.println(value);
> 更詳細用法請參考官方文檔https://www.elastic.co/guide/en/elasticsearch/client/java-api/6.6/_metrics_aggregations.html > 官方全部聚合Builder請參考https://www.elastic.co/guide/en/elasticsearch/client/java-rest/6.6/java-rest-high-aggregation-builders.html ###### 普通聚合查詢
/**
- 以aggstypes的方式metric度量，該方法不作分組，直接聚合統計metricName字段的sum、count、avg、min、max
- @param metricName 須要統計分析的字段
- @param aggsType sum、count、avg、min、max類型
- @param queryBuilder 查詢條件，若是不須要傳入null便可
- @param clazz
- @return 返回sum、count、avg、min、max的結果
- @throws Exception
*/
public double aggs(String metricName, AggsType aggsType, QueryBuilder queryBuilder, Classclazz) throws Exception;
double sum = elasticsearchTemplate.aggs("sum_premium", AggsType.sum,null,Main2.class);
double count = elasticsearchTemplate.aggs("sum_premium", AggsType.count,null,Main2.class);
double avg = elasticsearchTemplate.aggs("sum_premium", AggsType.avg,null,Main2.class);
double min = elasticsearchTemplate.aggs("sum_premium", AggsType.min,null,Main2.class);
//若是翻譯成sql：select max(sum_premium) from Main2
double max = elasticsearchTemplate.aggs("sum_premium", AggsType.max,null,Main2.class);
System.out.println("sum===="+sum);
System.out.println("count===="+count);
System.out.println("avg===="+avg);
System.out.println("min===="+min);
System.out.println("max===="+max);
- 分組普通聚合查詢
/**
- 普通聚合查詢，此方法最經常使用
- 以bucket分組以aggstypes的方式metric度量
- @param bucketName 以bucketName字段進行分組，在es中這個是「桶」的概念
- @param metricName 須要統計分析的字段
- @param aggsType
- @param clazz
- @return
*/
public Map aggs(String metricName, AggsType aggsType,QueryBuilder queryBuilder, Classclazz, String bucketName) throws Exception;
//若是翻譯成sql：select appli_name,max(sum_premium) from Main2 group by appli_name
Map map = elasticsearchTemplate.aggs("sum_premium", AggsType.sum,null,Main2.class,"appli_name");
map.forEach((k,v) -> System.out.println(k+" "+v));
==默認按照聚合結果降序排序== - 下鑽（2層）聚合查詢
/**
- 下鑽聚合查詢(無排序默認策略)，2次分組，注意目前此方法僅支持2層分組
- 以bucket分組以aggstypes的方式metric度量
- @param metricName 須要統計分析的字段
- @param aggsType
- @param queryBuilder
- @param clazz
- @param bucketNames 下鑽分組字段
- @return
- @throws Exception
*/
public Listaggswith2level(String metricName, AggsType aggsType,QueryBuilder queryBuilder, Class clazz ,String... bucketNames) throws Exception;
//select appli_name,risk_code,sum(sumpremium) from Main2 group by appli_name,risk_code
List
list.forEach(down ->
{
System.out.println("1:"+down.getLevel_1_key());
System.out.println("2:"+down.getLevel_2_key() + " "+ down.getValue());
}
);
- 統計聚合查詢
/**
- 統計聚合metric度量
- @param metricName 須要統計分析的字段
- @param queryBuilder
- @param clazz
- @return
- @throws Exception
*/
public Stats statsAggs(String metricName, QueryBuilder queryBuilder, Classclazz) throws Exception;
//此方法能夠一次查詢便返回針對metricName統計分析的sum、count、avg、min、max指標值
Stats stats = elasticsearchTemplate.statsAggs("sum_premium",null,Main2.class);
System.out.println("max:"+stats.getMax());
System.out.println("min:"+stats.getMin());
System.out.println("sum:"+stats.getSum());
System.out.println("count:"+stats.getCount());
System.out.println("avg:"+stats.getAvg());
- 分組統計聚合查詢
/**
- 以bucket分組，統計聚合metric度量
- @param bucketName 以bucketName字段進行分組
- @param metricName 須要統計分析的字段
- @param queryBuilder
- @param clazz
- @return
- @throws Exception
*/
public Map<String,Stats> statsAggs(String metricName, QueryBuilder queryBuilder, Classclazz, String bucketName) throws Exception;
和上一個方法相比，這個方法增長了分組的功能
Map<String,Stats> stats = elasticsearchTemplate.statsAggs("sum_premium",null,Main2.class,"risk_code");
stats.forEach((k,v) ->
{
System.out.println(k+" count:"+v.getCount()+" sum:"+v.getSum()+"...");
}
);
- 基數查詢
/** - 基數查詢，即count(distinct)返回一個近似值，並不必定會很是準確
- @param metricName 須要統計分析的字段
- @param queryBuilder
- @param clazz
- @return
- @throws Exception
*/
public long cardinality(String metricName, QueryBuilder queryBuilder, Classclazz) throws Exception;
//select count(distinct proposal_no) from Main2
long value = elasticsearchTemplate.cardinality("proposal_no",null,Main2.class);
System.out.println(value);
- 百分比聚合查詢
/**
- 百分比聚合 默認按照50%,95%,99%（TP50 TP95 TP99）進行聚合
- @param metricName 須要統計分析的字段,須要是數字類型
- @param queryBuilder
- @param clazz
- @return
- @throws Exception
*/
public Map percentilesAggs(String metricName, QueryBuilder queryBuilder, Classclazz) throws Exception;
/**
- 以百分比聚合 自定義百分比段位
- @param metricName 須要統計分析的字段,須要是數字類型
- @param queryBuilder
- @param clazz
- @param customSegment 自定義的百分比段位
- @return
- @throws Exception
*/
public Map percentilesAggs(String metricName, QueryBuilder queryBuilder, Classclazz,double... customSegment) throws Exception;
百分比聚合即查詢統計字段50%的數據在什麼值之內，95%的數據在什麼值之內
//下面的例子是取sum_premium這個字段的TP50 TP95 TP99
Map map = elasticsearchTemplate.percentilesAggs("sum_premium",null,Main2.class);
map.forEach((k,v) ->
{
System.out.println(k+" "+v);
}
);
//輸出結果是：
50.0 3.5
95.0 6.0
99.0 6.0
//即50%的sum_premium在3.5如下
//即95%的sum_premium在6.0如下
//即99%的sum_premium在6.0如下
//也能夠自定義百分比段位
Map map = elasticsearchTemplate.percentilesAggs("sum_premium",null,Main2.class,10,20,30,50,60,90,99);
- 百分等級聚合查詢
/**
- 以百分等級聚合 (統計在多少數值以內佔比多少)
- @param metricName 須要統計分析的字段,須要是數字類型
- @param queryBuilder
- @param clazz
- @param customSegment
- @return
- @throws Exception
*/
public Map percentileRanksAggs(String metricName, QueryBuilder queryBuilder, Classclazz,double... customSegment) throws Exception;
百分等級聚合即給定一個統計結果的段位，並查詢在段位範圍內出現的百分比是多少
//咱們給定一個sum_premium字段的統計段位1,4,5,9，即1如下、4如下、5如下、9如下
//最終獲取在上述範圍內數據出現的比百分
Map map = elasticsearchTemplate.percentileRanksAggs("sum_premium",null,Main2.class,1,4,5,9);
map.forEach((k,v) ->
{
System.out.println(k+" "+v);
}
);
//輸出結果爲：
8.333333333333332 1.0
58.333333333333336 4.0
75.0 5.0
100.0 9.0
//即8.3%的數據sum_premium字段值在1如下
//即58.3%的數據sum_premium字段值在4如下
//即75%的數據sum_premium字段值在5如下
//即100%的數據sum_premium字段值在9如下
- 過濾器聚合查詢
/**
- 過濾器聚合，能夠「變」的分組
- @param metricName 須要統計分析的字段
- @param aggsType 統計類型
- @param clazz
- @param queryBuilder
- @param filters FiltersAggregator過濾器封裝對象，每一個過濾器查詢出的數據結果均可以做爲一個桶
- @return
- @throws Exception
*/
public Map filterAggs(String metricName, AggsType aggsType, QueryBuilder queryBuilder,Classclazz, FiltersAggregator.KeyedFilter... filters) throws Exception;
過濾器聚合讓es的聚合功能很是的靈活，它能夠靈活定製分組規格
//如下的例子是以risk_code是0101爲1組，risk_code是0103或0104爲1組，求sum_premium在分組內的和
Map map = elasticsearchTemplate.filterAggs("sum_premium", AggsType.sum, null,Main2.class,
new FiltersAggregator.KeyedFilter("0101", QueryBuilders.matchPhraseQuery("risk_code", "0101")),
new FiltersAggregator.KeyedFilter("0103或104", QueryBuilders.matchQuery("risk_code", "0103 0104")));
map.forEach((k, v) ->
System.out.println(k + " " + v)
);
- 直方圖聚合查詢
/**
- 直方圖聚合
- @param metricName 須要統計分析的字段
- @param aggsType 統計類型
- @param queryBuilder
- @param clazz
- @param bucketName 以bucketName字段進行分組
- @param interval 分組字段值的間隔
- @return
- @throws Exception
*/
public Map histogramAggs(String metricName, AggsType aggsType,QueryBuilder queryBuilder,Classclazz,String bucketName,double interval) throws Exception;
直方圖聚合是統計針對分組字段，每隔X的值統計一次度量值
//統計sum_premium的數值每3的倍數，統計一次proposal_no的個數
Map map = elasticsearchTemplate.histogramAggs("proposal_no", AggsType.count, null,Main2.class,"sum_premium",3);
map.forEach((k, v) ->
System.out.println(k + " " + v)
);
//輸出結果爲：
0.0 2
3.0 3
6.0 1
- 日期直方圖聚合查詢
/**
- 日期直方圖聚合
- @param metricName 須要統計分析的字段
- @param aggsType 統計類型
- @param queryBuilder
- @param clazz
- @param bucketName
- @param interval 日期分組間隔
- @return
- @throws Exception
*/
public Map dateHistogramAggs(String metricName, AggsType aggsType, QueryBuilder queryBuilder, Classclazz, String bucketName, DateHistogramInterval interval) throws Exception;
日期直方圖與直方圖相似，只是將分組的字段替換爲日期類型
//統計input_date每兩個小時sum_premium的金額總合
Map map = elasticsearchTemplate.dateHistogramAggs("sum_premium", AggsType.sum, null,Main2.class,"input_date", DateHistogramInterval.hours(2));
map.forEach((k, v) ->
System.out.println(k + " " + v)
);
###### 更多聚合查詢的方式 es支持的聚合方式遠不止於此，工具只是針對最經常使用的一部分查詢方式進行封裝，以減輕代碼量 例如咱們須要實現一個範圍聚合，能夠經過如下例子實現：
//以sum_premium的範圍分組，並統計sum_premium的數量
AggregationBuilder aggregation = AggregationBuilders.range("range").field("sum_premium").addUnboundedTo(1).addRange(1,4).addRange(4,100).addUnboundedFrom(100);
aggregation.subAggregation(AggregationBuilders.count("agg").field("proposal_no.keyword"));
Aggregations aggregations = elasticsearchTemplate.aggs(aggregation,null,Main2.class);
Range range = aggregations.get("range");
for (Range.Bucket entry : range.getBuckets()) {
ValueCount count = entry.getAggregations().get("agg");
long value = count.getValue();
System.out.println(entry.getKey() + " " + value);
}
> 更多聚合API用法詳見https://www.elastic.co/guide/en/elasticsearch/client/java-rest/6.6/java-rest-high-aggregation-builders.html ## 運維功能 ###### 打印請求es服務日誌 若是須要調試，須要獲取請求es的json報文，能夠配置es索引結構實體類註解的打印報文開關```printLog = true```
@ESMetaData(indexName = "index",indexType = "main4", number_of_shards = 5,number_of_replicas = 0,printLog = true)
public class Main2 implements Serializable {
此項配置默認爲關閉，開啓後僅僅支持幾個經常使用功能的日誌打印，若是須要支持更多的功能打印，請在相應位置添加以下代碼便可
if(metaData.isPrintLog()){
logger.info(searchSourceBuilder.toString());
}
```
將來規劃
- 爲了更加簡化代碼，下一步工具將參照spring-data-jpa或mybatis與spring的集成方式，能夠動態實現針對每一個entity的接口，並自動繼承經常使用方法
- 添加完善經常使用API
- 提供一套前端演示(包含springboot的後端服務+antd(react)前端功能演示)，進一步下降學習和使用elasticsearch的成本
- 1. elasticsearch RestHighLevelClient 使用方法及封裝工具
- 2. elasticsearch 使用RestHighLevelClient
- 3. Elasticsearch高級API-通用方法封裝
- 4. JDBC操做封裝工具類JdbcUtils及其使用方法
- 5. OkHttp使用及工具類封裝
- 6. ElasticSearch 工具類封裝（基於ElasticsearchTemplate）
- 7. 使用RestHighLevelClient報錯：ClassNotFoundException: org.elasticsearch.common.xcontent.DeprecationHandler
- 8. CSS 經常使用工具方法封裝
- 9. JDBC——原理、步驟、使用方法、BaseDao封裝工具類
- 10. JavaScript經常使用方法（工具類的封裝）
- 更多相關文章...
- • C# 封裝 - C#教程
- • jQuery Mobile 工具欄 - jQuery Mobile 教程
- • Composer 安裝與使用
- • PHP開發工具
-
每一个你不满意的现在，都有一个你没有努力的曾经。
- 1. eclipse設置粘貼字符串自動轉義
- 2. android客戶端學習-啓動模擬器異常Emulator: failed to initialize HAX: Invalid argument
- 3. android.view.InflateException: class com.jpardogo.listbuddies.lib.views.ListBuddiesLayout問題
- 4. MYSQL8.0數據庫恢復 MYSQL8.0ibd數據恢復 MYSQL8.0恢復數據庫
- 5. 你本是一個肉體，是什麼驅使你前行【1】
- 6. 2018.04.30
- 7. 2018.04.30
- 8. 你本是一個肉體，是什麼驅使你前行【3】
- 9. 你本是一個肉體，是什麼驅使你前行【2】
- 10. 【資訊】LocalBitcoins達到每週交易比特幣的7年低點
- 1. elasticsearch RestHighLevelClient 使用方法及封裝工具
- 2. elasticsearch 使用RestHighLevelClient
- 3. Elasticsearch高級API-通用方法封裝
- 4. JDBC操做封裝工具類JdbcUtils及其使用方法
- 5. OkHttp使用及工具類封裝
- 6. ElasticSearch 工具類封裝（基於ElasticsearchTemplate）
- 7. 使用RestHighLevelClient報錯：ClassNotFoundException: org.elasticsearch.common.xcontent.DeprecationHandler
- 8. CSS 經常使用工具方法封裝
- 9. JDBC——原理、步驟、使用方法、BaseDao封裝工具類
- 10. JavaScript經常使用方法（工具類的封裝）