ES常用的JAVA API语法

ES JAVA API请求地址：线上:集群名称: data_cluster集群地址: es.data…comtcp端口：9300http端口: 80POM文件配置<dependency><groupId>org.elasticsearch</groupId><artifactId>elasticsearch</artifactId>&lt

习惯了想你

2322人浏览 · 2020-12-25 14:41:06

习惯了想你 · 2020-12-25 14:41:06 发布

ES JAVA API
请求地址：
线上:

集群名称: data_cluster
集群地址: es.data…com
tcp端口：9300
http端口: 80

POM文件配置

<dependency>
    <groupId>org.elasticsearch</groupId>
    <artifactId>elasticsearch</artifactId>
    <version>2.3.2</version>
</dependency>

客户端生成

Settings settings = Settings.settingsBuilder()
        .put("cluster.name", "data_test_cluster")//集群名称
        .put("client.transport.sniff", "true")
        .build();
Client client = TransportClient.builder().settings(settings).build()
        .addTransportAddress(new InetSocketTransportAddress(InetAddress.getByName("test.es.da.com"), 9300));//集群地址
        ```

search操作
3.1 最基本的search操作

SearchResponse response = client.prepareSearch("index_name").get(); //查询索引
SearchResponse response1 = client.prepareSearch().get();
获取查询的字段
response.getSource().get("postData")

3.2 scroll
作用：scroll的作用是批量获取查询结果，结果快照在内存中保存一段时间，然后用户根据scroll_id来读取结果，直到读取完整。
实际深度查询时，强烈建议使用scroll进行查询。与from-size最大的区别就是，from+size默认只能获取查询结果不超过1万条的数据（防止一次数据过多打爆内存），但是scroll通过批量的方式读取而没有限制。

Client client = client();
SearchResponse response = client.prepareSearch("log.ecloglog_all")
        .addSort(SortParseElement.DOC_FIELD_NAME, SortOrder.ASC)//若想遍历所有的数据，最好根据文档写入时间排序
        .setScroll(new TimeValue(60000))  //设置保存在内存中的时间
        .setQuery(QueryBuilders.termQuery("input_type","log"))//.setSearchType(SearchType.SCAN),经验证，添加scan后，对于java api,hits[]里面的结果为空（是一个大坑），但是对于http形式的，Hits[]里面还有值。
        .setSize(10000)//规定的返回值个数，默认是10个
        .get();
do{
    for(SearchHit hit:response.getHits().getHits()){
        System.out.println(hit);
    }
    response = client.prepareSearchScroll(response.getScrollId()).setScroll(new TimeValue(6000)).get();//这里读取
}while(response.getHits().getHits().length!=0);

3.3 multi search
作用：N个search操作一起执行，结果返回N个Response,几个search相互独立，互不影响。

SearchRequestBuilder srb1 = client.prepareSearch("log.ecloglog_all")
        .setQuery(QueryBuilders.queryStringQuery("level:INFO")).setSize(2);
SearchRequestBuilder srb2 = client.prepareSearch("log.ecloglog_all")
        .setQuery(QueryBuilders.termQuery("element_id", "reculike")).setSize(4);

MultiSearchResponse sr = client.prepareMultiSearch().add(srb1).add(srb2).get();
for(MultiSearchResponse.Item item : sr.getResponses()){
   //todo some thing
}

3.4 query_string和Simple Query String Query
query_string最常见的是全文搜索：

SearchResponse response = client.prepareSearch("log.data__worker_log_all")
        .setQuery(QueryBuilders.queryStringQuery("level:INFO")//需要匹配的string
                .defaultField("_all")//在哪些字段匹配，默认_all
                .defaultOperator(QueryStringQueryBuilder.Operator.OR)//分词数组中与字段匹配关系，默认是or，与bool 相似
                .minimumShouldMatch("2")//在or时生效，应该匹配的分词数组最小数组个数。
                .allowLeadingWildcard(true)//通匹配是否可以出现在字段开头，默认为true
        ).get();
Simple Query String Query：相比query_string，它从来不抛出异常。

3.5 Aggregation聚合操作
聚合需要掌握两个最基本的概念：bucket，metrics。
bucket：桶，满足某一条件的文档集合。类似数据库中的group by。
metrics(指标):min、max、agv、sum，terms。
3.5.1
一般使用桶来聚合，使用指标来提取桶内的信息。

//将age相同的文档作为一个桶，统计这个桶内的平均工资。
SearchRequestBuilder sbuilder = client.prepareSearch("my_index");
TermsBuilder teamAgg= AggregationBuilders.terms("team_name").field("age");    //这个作为桶
SumBuilder salaryAgg= AggregationBuilders.avg("avg_salary ").field("salary");    //这个作为嵌套的指标
sbuilder.addAggregation(teamAgg.subAggregation(salaryAgg));
SearchResponse response = sbuilder.get();

Map<String, Aggregation> aggMap = response.getAggregations().asMap();
StringTerms teamAg= (StringTerms) aggMap.get("team");
Iterator<Terms.Bucket> teamBucketIt = teamAg.getBuckets().iterator();  //遍历buckets
while (teamBucketIt .hasNext()) {
    Terms.Bucket buck = teamBucketIt .next();  //访问bucket内数据
    String key = (String)buck.getKey();
    long doc_count = buck.getDocCount();
    List list = buck.getAggregations().asList();
}

3.5.2 max、min、sum、avg、count 聚合
对于一般的指标，使用大同小异，仅仅作为一个MetricsAggregationBuilder嵌套在桶中，使用如下：

MetricsAggregationBuilder aggregation = AggregationBuilders .max("agg") .field("height");
MetricsAggregationBuilder aggregation = AggregationBuilders .min("agg") .field("height");
MetricsAggregationBuilder aggregation = AggregationBuilders .sum("agg") .field("height");
MetricsAggregationBuilder aggregation = AggregationBuilders .avg("agg") .field("height");
MetricsAggregationBuilder teamAgg= AggregationBuilders.count("age_count").field("age");   //http形式名称为value_count

3.5.3 stats和extended_stats
若用户需要对某一个域同时提取几个指标，就可以使用到指标：stats和extended_stats。
stats可以一次性提取的指标包括： count、min、max、avg、sum。

MetricsAggregationBuilder aggregation = AggregationBuilders .stats("agg") .field("height");

extended_stats可以一次性提取的指标包括： count、min、max、avg、sum、sum_of_squares、variance、std_deviation、std_deviation_bounds。具体各参数意义，请参考官网。

MetricsAggregationBuilder teamAgg= AggregationBuilders.extendedStats("team").field("name");

3.5.4 percentiles和percentiles Ranks概率聚合
percentiles作用：概率指标，只能适用于数值型域，它分析values的概率分布。

MetricsAggregationBuilder perAgg= AggregationBuilders.percentiles("per").field("age");

默认会统计以下百分比：“values” : { “1.0”: 15, “5.0”: 20, “25.0”: 23, “50.0”: 25, “75.0”: 29, “95.0”: 60, “99.0”: 150 }，“5.0”：20指的是:value<20的值个数占总个数的5%。用户可以通过接口更改默认的统计点，下例表示value<10，value<50，value<99分别占的比例。

MetricsAggregationBuilder perAgg= AggregationBuilders.percentiles("age1").field("age").percentiles(10,50,99);//取值0~100

percentiles Ranks：用于统计value在某个区间内的比例变化。

MetricsAggregationBuilder aggregation = AggregationBuilders.percentileRanks("age1").field("age").percentiles(20,30);

该函数和第二点的区别是，第二点指的是在某个比例范围内，value的取值；该函数指的是在某个value的范围内，比例的取值。相当与一次函数f(x)=y，已知x，计算y；已知y，求x。注意：只有数据量足够大，相互推到越精确。

3.5.5 Cardinality统计聚合
作用：相当于sql 上的distinct count,用于统计某列不重复数据的个数

MetricsAggregationBuilder me = AggregationBuilders.cardinality("name_count").field("name"); //统计名字这列不重复的属性值个数

3.5.6 Geo Bounds和Geo Distance Aggregation地理位置相关的聚合
Geo Bounds:作用于地理信息类型的列，主要求出地理数据的边界框（左上，右下）

GeoBoundsBuilder geo = AggregationBuilders.geoBounds("geo_agg").field("location").wrapLongitude(true);

Geo Distance Aggregation：主要以到某个中心节点的距离为桶，距离默认以m为单位。

AggregationBuilder ar = AggregationBuilders.geoDistance("agg_dist").field("location")
        .point(new GeoPoint(1,-1)).unit(DistanceUnit.KILOMETERS).addUnboundedTo(1000).addRange(100,5000).addUnboundedFrom(5000);

以上代码表示的含义：以经纬度（1，-1）的点为半径，桶的距离分别是(-infinity,1000)，[1000,5000),[5000,+infinity)

3.5.7 Top hits
作用:主要跟踪在聚合内最相关的文档。主要用于subAggregation里，根据排序规则来返回每个bcket里最相关的文档。主要参数：

from：从结果中哪个位置开始返回。
size：返回结果多大。
sort：返回结果根据哪些域排序。

AggregationBuilder aggregation1 = AggregationBuilders.terms("age1").field("age")
        .subAggregation(AggregationBuilders.topHits("top_heat").addSort("salary", SortOrder.DESC).setSize(2).setFrom(0));

3.5.8 Global Aggregation
作用: 将所有文档（search查询下index/tyupe下所有的文档）作为一个全局的桶，而不考虑是否有query限制条件。

GlobalBuilder aggregationBuilders = AggregationBuilders.global("agg").subAggregation(AggregationBuilders.terms("salary").field("salary"));

3.5.9 Filter Aggregation 和 Filters Aggregation
Filter生成了一个满足一定条件的一个桶，条件包含query,filter等。

FilterAggregationBuilder fil = AggregationBuilders.filter("fil").filter(QueryBuilders.termQuery("name", "james"))
      .subAggregation(AggregationBuilders.min("sala").field("salary"));

Filters:多个Filter叠加，但是作用域却没有累加，相当于依次执行每个fIlter。聚合的时候，每一个filter都会形成一个桶。

FiltersAggregationBuilder fils = AggregationBuilders.filters("filters1")
      .filter("age1", QueryBuilders.termQuery("age", 25))
      .filter("name1", QueryBuilders.termQuery("name1", "james"));

3.5.10 Missing Aggregation缺失值统计
作用：统计缺失某些域的文档个数。

MissingBuilder mb = AggregationBuilders.missing("miss_some_value").field("position");

3.5.11 Nested Aggregation和Reverse nested Aggregation
作用: 嵌套类型和反嵌套类型的数据的聚合

Nested Aggregation，主要是为了访问嵌套类内部的变量。

NestedBuilder agg = AggregationBuilders.nested("test").path("person") //这里首先定义嵌套类型,则子聚合的变量只能是嵌套(person)里面的属性
        .subAggregation(AggregationBuilders.avg("age").field("person.age"));  //这里开始使用嵌套类型数据来作为查询字句

SearchResponse sr = sbuilder.addAggregation(agg).get();

Reverse nested Aggregation：和嵌套类型的区别是，当进入一个嵌套内部后，如何访问嵌套类型外的数据。

AggregationBuilder agg = AggregationBuilders.nested("nested_name").path("person") //第一层嵌套
        .subAggregation(AggregationBuilders.terms("name").field("person.name"))
        .subAggregation(AggregationBuilders.reverseNested("reverse_name")//跳出这个嵌套
        .subAggregation(AggregationBuilders.terms("parent_name").field("sale")));
SearchResponse sr = sbuilder.addAggregation(agg).get();

3.5.12 桶之间的Order排序
作用：对于桶之间的排序，排序分类：

order(Terms.Order.term(true)) ：按分桶的那个字母顺序升序排列
order(Terms.Order.count(true))：按照doc_count排序
通过子聚合的结果排序：

AggregationBuilder agg = AggregationBuilders.terms("genders").field("gender").order(Terms.Order.aggregation("avg_height", false))  //子聚合的聚合名称
    .subAggregation(AggregationBuilders.avg("avg_height").field("height"))

3.5.13 Range Aggregation、Date Range Aggregation、Ip Range Aggregation 范围聚合
Range Aggregation:以下分了三个范围：(-infinity, 2900)，[2900，3100)，[3100,+infinity)

AggregationBuilder ar = AggregationBuilders.range("ranges").field("salary").addUnboundedFrom(2900).addRange(2900,3100).addUnboundedTo(3100)
        .subAggregation(AggregationBuilders.stats("stats").field("salary"));

Date Range Aggregation:和Range 聚合的区别是：可以以时间为分割线

RangeBuilder aggs = AggregationBuilders.range("range1")
        .field("dateline").format("yyyy/MM/yy HH:mm:ss").addUnboundedFrom(1480657961).addUnboundedTo(1490657961);

Ip Range Aggregation：以ip地址和ip mask为分割线

AggregationBuilder aggregation = AggregationBuilders.ipRange("agg").field("ip")
                .addUnboundedTo("192.168.1.0")             // from -infinity to 192.168.1.0 (excluded)
                .addRange("192.168.1.0", "192.168.2.0")    // from 192.168.1.0 to 192.168.2.0 (excluded)
                .addUnboundedFrom("192.168.2.0");
AggregationBuilder aggregation = AggregationBuilders.ipRange("agg").field("ip")
                .addMaskRange("192.168.0.0/32")
                .addMaskRange("192.168.0.0/24")
                .addMaskRange("192.168.0.0/16");

3.5.14 Histogram Aggregation和Date Histogram Aggregation柱状图
作用：规定间隔内统计一次数据，类似柱状图

Histogram Aggregation

DateHistogramBuilder aggs = AggregationBuilders.dateHistogram("dataHisto").field("age").interval(2)
        .minDocCount(1)   //桶的最小值
       .extendedBounds((long) 0, (long) 1090); //限定每个桶的边界

Date Histogram Aggregation：以时间作为一个桶，时间间隔单位有：秒，分钟，小时，天，周，月，季度，年。es也支持2秒、3分钟这种类型的桶。

SearchResponse sr = client.prepareSearch("log.hotel_order_opstep_all")
        .addAggregation(AggregationBuilders.dateHistogram("histo")//bucket name。
                .field("es_timestamp")//哪个域，一般是typpe是date域
                .interval(DateHistogramInterval.DAY)//设置间隔
        ).get();

3.5.15 Significant Terms
作用：找出与前置北京最接近的数据，比如推荐与某部电影相似的电影

AggregationBuilder aggregation =
	        AggregationBuilders
	                .significantTerms("significant_countries")
	                .field("address.country");
	SearchResponse sr = client.prepareSearch()
	        .setQuery(QueryBuilders.termQuery("gender", "male"))
	        .addAggregation(aggregation)
	        .get();

3.5.16 sort排序

SearchRequestBuilder sbuilder = client.prepareSearch("my_index").addSort("age", SortOrder.DESC);
TermQueryBuilder termQueryBuilder = QueryBuilders.termQuery("name", "james");
SearchResponse sr = sbuilder.setQuery(termQueryBuilder).get();

Query/Filter DSL操作（Query/Filter Domain Specific Language）
4.1 Match All Query全文搜索

MatchAllQueryBuilder qb = QueryBuilders.matchAllQuery();
SearchResponse sr = sbuilder.setQuery(qb).get();

每个文档的得分_score都是1.0

4.2 bool查询
作用：类似mysql and（where里面多个条件需要同时满足）

SearchResponse response = client.prepareSearch("my_index")
        .setQuery(QueryBuilders.boolQuery()
                .must(QueryBuilders.termQuery("name", "james"))
                .should(QueryBuilders.termQuery("position", "beijing"))
                .should(QueryBuilders.rangeQuery("age").from(23)))
                .setSize(100).get();

其中：bool查询包换以下查询之一:must，should，must_not，它们的出现可以任意组合。should条件可以不满足，若满足了score得分会更高。

4.3 Fuzzy Query模糊查询
作用：找出指定字段类似的文档

SearchResponse response = client.prepareSearch("my_index")
        .setQuery(QueryBuilders.fuzzyQuery("name", "james").fuzziness(Fuzziness.TWO)).get();

其中参数fuzziness可选ZERO,ONE,TWO,AUTO,表示模糊查询时单词之间的边距距离最大值，参数为AUTO时，编辑距离最大值自动根据单词长度调整。最大值只能设置为2。

4.4 phrase Query短语查询
作用：主要用于analyzed类型的字段上，规定了query经过分割后的分词数组之间的所有分词前后间隔总和不能大于slop(默认为0)。

SearchResponse response = client.prepareSearch("my_index")
        .setQuery(QueryBuilders.matchPhraseQuery("an","a11-a13").slop(1)).get();

4.5 Common Terms Query
作用:充分考虑了了stop-word的优先级，将高频组（一般为非停词器）和低频组分为两组，首先根据高频组查询出相似文档和score，其次在这个相似性文档中再根据低频组调整score。cutoffFrequency设置高低频词的界限。

SearchResponse response = client.prepareSearch("my_index")
        .setQuery(QueryBuilders.commonTermsQuery("an","a11 is").cutoffFrequency((float)0.001)).get();

4.6 terms查询
作用：多个term查询的分别查询，相互不影响

SearchResponse response = client.prepareSearch("my_index")
        .setQuery(QueryBuilders.termsQuery("name","james2","james1")).get();

4.7 range查询

RangeQueryBuilder qb = QueryBuilders.rangeQuery("age").from(10).to(30);

其中：from, gte:>=to, lt:<, gt:>, lte:<=

4.8 exists 查询
作用：判断某些字段是否存在

ExistsQueryBuilder qb = QueryBuilders.existsQuery("an");

4.9 WildCard 查询
通配符查询，主要只使用两个特殊字符：？，代表0-多个字符串(包括空)，?代表任一字符串（不包括空）

WildcardQueryBuilder qb = QueryBuilders.wildcardQuery("na","a11*");

4.10 Regexp Query正则表达式查询
regex与wildcard使用上的区别就是：regex查询能写出这样更复杂的模式。

RegexpQueryBuilder qb = QueryBuilders.regexpQuery("noan","a21.*"); //匹配a21开头的串

4.11 filter和query同时使用
Search API只能包含query查询字句，有时这个query可以省略。如果想同时query和filter，必须使用如下语法:{filtered：{filter:{},query:"{}}}

FilteredQueryBuilder qb =QueryBuilders.filteredQuery(QueryBuilders.matchQuery("name","james"),QueryBuilders.termQuery("age",25));

过时用法，一般使用bool must和filter代替.

QueryBuilders.boolQuery().must(QueryBuilders.termQuery("name","james")).filter(QueryBuilders.termQuery("age",25));

4.12 Data range

POST metrics.data_log_esclientapi/_search
{
    "query":{
        "range": {
           "searchtimestamp": {
              "from": "2016/12/26 06:08:00",
              "to": "2016/12/26 06:10:19",
              "format":"yyyy/MM/dd hh:mm:ss"
           }
        }
    }
}

4.13 SpanNearQuery 查询跨度查询
根据查询的词之间距离来判定相似性，举例说明：比如message：“the quick brown fox jumps over the lazy dog”

SpanNearQuery snq=new SpanNearQuery(quick_brown_dog,4,true);//按正常顺序,跨度为4,对三个项进行查询
assertNoMatches(snq);//无法匹配
SpanNearQuery snq=new SpanNearQuery(quick_brown_dog,5,true);//按正常顺序,跨度为5,对三个项进行查询
assertOnlyBrownFox(snq);//匹配成功   
SpanNearQuery snq=new SpanNearQuery(new SpanQuery[]{lazy,fox},3,false);//按相反顺序,跨度为3,对三个项进行查询
assertOnlyBrownFox(snq);//匹配成功

4.14 SpanFirstQuery 查询查询
对出现在一个域中前n个位置的跨度查询，举例说明：比如message：“the quick brown fox …”

SpanzFirtsQuery sfq=new SpanFirstQuery(brown,2);
assertNoMatches(sfq);//前2个位置的跨度无法匹配
sfq=new SpanFirstQuery(brown,3);
assertOnlyBrownFox(sfq);//前3个位置匹配成功