elasticsearch RestHighLevelClient 使用方法及封装工具

最新推荐文章于 2024-03-17 22:28:08 发布

weixin_30736301

最新推荐文章于 2024-03-17 22:28:08 发布

阅读量3.6w

点赞数 6

文章标签：大数据 java c/c++

原文链接：http://www.cnblogs.com/zxporz/p/10948314.html

版权

EsClientRHL

git地址：https://gitee.com/zxporz/ESClientRHL

EsClientRHL

EsClientRHL是一个可基于springboot的elasticsearch RestHighLevelClient客户端调用封装工具，主要提供了es索引结构工具、es索引数据增删改工具、es查询工具、es数据分析工具。

基于elasticsearch6.6+版本进行开发，由于采用RestHighLevelClient，所以版本兼容问题应该能得到一定改善。

更新日志

更新日期	更新内容
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
删除索引结构

CRUD
LowLevelClient查询
新增索引数据
批量新增索引数据
覆盖更新索引数据
部分更新索引数据
删除索引数据
判断索引数据是否存在
原生查询
支持、查询条件的定制查询
支持分页、高亮、排序、查询条件的定制查询
count查询
scroll查询（用于大数据量查询）
~~模版查询~~
搜索建议
根据ID查询
mget查询
按照多索引查询说明（2013-03-19新增）

聚合查询
原生聚合查询
普通聚合查询
分组普通聚合查询
下钻（2层）聚合查询
统计聚合查询
分组统计聚合查询
基数查询
百分比聚合查询
百分等级聚合查询
过滤器聚合查询
直方图聚合查询
日期直方图聚合查询

工具源码结构介绍

annotation

存放一些注解，用于简化组件使用

config

基于springboot的自动化的功能，包括自动配置es客户端组件以及自动管理索引结构的功能

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(Class clazz) 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 list = new ArrayList<>();
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 List search(QueryBuilder queryBuilder, Class clazz) throws Exception;

//这里简单通过matchall（全查询）的方式进行演示
//QueryBuilder的用法会在单独章节介绍
List main2List = elasticsearchTemplate.search(new MatchAllQueryBuilder(),Main2.class);
main2List.forEach(main2 -> System.out.println(main2));


###### 支持分页、高亮、排序、查询条件的定制查询

/**

支持分页、高亮、排序的查询
@param queryBuilder 查询条件
@param pageSortHighLight 封装了分页、排序、高亮的规格信息
@param clazz 泛型对应类类型
@return 泛型定义好的es索引结构实体类查询结果集合
@throws Exception
*/
public PageList search(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 = new 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 List scroll(QueryBuilder queryBuilder, Class clazz, long time) throws Exception;

/**

scroll方式查询，用于大数据量查询，默认了保留时间为2小时(Constant.DEFAULT_SCROLL_TIME)
@param queryBuilder
@param clazz
@return
@throws Exception
*/
public List scroll(QueryBuilder queryBuilder, Class clazz) throws Exception;

//默认scroll镜像保留2小时
List main2List = elasticsearchTemplate.scroll(new MatchAllQueryBuilder(),Main2.class);
main2List.forEach(main2 -> System.out.println(main2));

//指定scroll镜像保留5小时
//List main2List = elasticsearchTemplate.scroll(new MatchAllQueryBuilder(),Main2.class,5);

###### ~~模版查询~~
暂时无法使用该方法，原因为官方API SearchTemplateRequestBuilder仍保留对transportClient 的依赖，但Migration Guide 中描述需要把transportClient迁移为RestHighLevelClient

###### 搜索建议

搜索建议功能能够快速提示要搜索的内容（请参考百度搜索功能），搜索建议字段需要配置suggest属性为true

/**

搜索建议方法
@param fieldName 要搜索的字段（需要设置该字段mapping配置suggest属性为true）
@param fieldValue 要搜索的内容
@param clazz
@return 返回搜索结果列表搜索建议默认条数为10条
@throws Exception
*/
public List completionSuggest(String fieldName,String fieldValue,Class clazz) throws Exception;

List list = elasticsearchTemplate.completionSuggest("appli_name", "1", Main2.class);
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, Class clazz) throws Exception;

Main2 main2 = elasticsearchTemplate.getById("main2", Main2.class);
System.out.println(main2);


###### mget查询

/**

根据ID列表批量查询
@param ids ID主键数组
@param clazz
@return
@throws Exception
*/
public List mgetById(M[] ids, Class clazz) throws Exception;

String[] list = {"main2","main3"};
List listResult = elasticsearchTemplate.mgetById(list, Main2.class);
listResult.forEach(main -> System.out.println(main));

#### QueryBuilder常用用法展示

###### 精准查询

//精准查询的字段需要设置keyword属性（默认该属性为true），查询时fieldname需要带上.keyword
QueryBuilder queryBuilder = QueryBuilders.termQuery("appli_name.keyword","456");
List list = elasticsearchTemplate.search(queryBuilder,Main2.class);
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 = elasticsearchTemplate.search(queryBuilder,Main2.class);
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，后续将添加聚合查询的跨索引查询

//传入main5、main6作为需要被2个索引范围
List list = elasticsearchTemplate.search(QueryBuilders.matchAllQuery(),Main6.class,"main5","main6");
System.out.println(list.size());
//查询结果仅包含main6的字段结果
list.forEach(main6 -> System.out.println(main6));


这是一个新增的接口方法实例，均在最后添加了可变长入参的方式

/**
* 非分页查询(跨索引)
* 目前暂时传入类类型
* @param queryBuilder
* @param clazz
* @return
* @throws Exception
*/
public List search(QueryBuilder queryBuilder, Class clazz,String... indexs) throws Exception;



==建议跨索引查询时多索引之间尽量字段重合度高==



#### 聚合查询


###### 原生聚合查询

/**

聚合基础方法，此方法较少封装，其目的为了满足工具无法实现的聚合查询
@param aggregationBuilder 聚合内容
@param queryBuilder 检索条件
@param clazz
@return 聚合结果（官方原生聚合结果）
@throws Exception
*/
public Aggregations aggs(AggregationBuilder aggregationBuilder, QueryBuilder queryBuilder, Class clazz) 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, Class clazz) 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, Class clazz, 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 List aggswith2level(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 = elasticsearchTemplate.aggswith2level("sum_premium", AggsType.sum,null,Main2.class,"appli_name","risk_code");
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, Class clazz) 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, Class clazz, 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, Class clazz) 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, Class clazz) throws Exception;

/**

以百分比聚合自定义百分比段位
@param metricName 需要统计分析的字段,需要是数字类型
@param queryBuilder
@param clazz
@param customSegment 自定义的百分比段位
@return
@throws Exception
*/
public Map percentilesAggs(String metricName, QueryBuilder queryBuilder, Class clazz,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, Class clazz,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,Class clazz, 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,Class clazz,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, Class clazz, 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的成本

转载于:https://www.cnblogs.com/zxporz/p/10948314.html

weixin_30736301

关注

6
点赞
踩
51

收藏

觉得还不错? 一键收藏
0
评论
elasticsearch RestHighLevelClient 使用方法及封装工具

目录 EsClientRHL 更新日志开发原因：使用前你应该具有哪些技能工具功能范围介绍工具源码结构介绍开始使用未来规划 git地址：https://gitee.com/zx...
复制链接

扫一扫