Elasticsearch之Java简单操作

1. 创建索引，index和type，index.max_result_window代表返回的最大结果数量，可用于分页，但是最多可以取该数量，如果要取更多的就需要使用游标获取。

import org.apache.http.message.BasicHeader;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequest;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateResponse;
import org.elasticsearch.common.xcontent.XContentBuilder;
import org.elasticsearch.index.query.*;
import org.elasticsearch.rest.RestStatus;
import org.elasticsearch.script.Script;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.AggregationBuilders;
import org.elasticsearch.search.aggregations.BucketOrder;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramAggregationBuilder;
import org.elasticsearch.search.aggregations.bucket.histogram.DateHistogramInterval;
import org.elasticsearch.search.aggregations.bucket.terms.TermsAggregationBuilder;
import org.elasticsearch.search.aggregations.metrics.sum.SumAggregationBuilder;
import org.elasticsearch.search.aggregations.pipeline.PipelineAggregatorBuilders;
import org.elasticsearch.search.aggregations.pipeline.bucketselector.BucketSelectorPipelineAggregationBuilder;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.sort.FieldSortBuilder;
import org.elasticsearch.search.sort.SortOrder;
import org.joda.time.DateTimeZone;

import javax.inject.Named;
import java.io.IOException;
import java.math.BigDecimal;
import java.util.*;
import java.util.stream.Collectors;

import static org.elasticsearch.common.xcontent.XContentFactory.jsonBuilder;

CreateIndexRequest request = new CreateIndexRequest(index);
                    request.mapping(type, buildMapping()).settings(MapUtils.m("index.max_result_window", 200000));
                    rhlClient.indices().create(request);

 // 索引内容
    private XContentBuilder buildMapping() throws IOException {
        XContentBuilder builder = jsonBuilder().prettyPrint().startObject().startObject("ORDER_ES").startObject("properties");
        buildKeyword(builder, "orderId");
        buildLong(builder, "id");
        buildInteger(builder, "orderType");
        buildDate(builder, "payDatetime");
        buildText(builder, "detail");
        buildBoolean(builder, "disabled");
        return builder.endObject().endObject().endObject();
    }
    // 构建各种类型的字段
    private void buildKeyword(XContentBuilder builder, String name) throws IOException {
        builder.startObject(name).field("type", "keyword").endObject();
    }
    private void buildText(XContentBuilder builder, String name) throws IOException {
        builder.startObject(name).field("type", "text").endObject();
    }
    private void buildLong(XContentBuilder builder, String name) throws IOException {
        builder.startObject(name).field("type", "long").endObject();
    }
    private void buildInteger(XContentBuilder builder, String name) throws IOException {
        builder.startObject(name).field("type", "integer").endObject();
    }
    private void buildDate(XContentBuilder builder, String name) throws IOException {
        builder.startObject(name).field("type", "date").endObject();
    }
    private void buildBoolean(XContentBuilder builder, String name) throws IOException {
        builder.startObject(name).field("type", "boolean").endObject();
    }

2. 删除索引

 DeleteIndexRequest request = new DeleteIndexRequest(index);
            rhlClient.indices().delete(request);

3. 添加数据，info为你的实体类，resultMap(info)把它转为map

IndexRequest indexRequest = new IndexRequest(index, type, info.getOrderId());
                        indexRequest.source(resultMap(info));
                        IndexResponse response = rhlClient.index(indexRequest);

4. 更新数据

UpdateRequest updateRequest = new UpdateRequest(index, type, info.getOrderId());
                        UpdateResponse response = rhlClient.update(updateRequest.doc(resultMap(info)));

5. 根据id查询

private Map<ID, E> $loads(Collection<ID> ids) {
    if (CollectionUtils.isEmpty(ids)) {
      return Collections.emptyMap();
    }
String[] idsArray = new String[ids.size()];
    int i = 0;
    for (ID id : ids) {
      idsArray[i++] = id.toString();
    }
    BoolQueryBuilder bqb = QueryBuilders.boolQuery().must(QueryBuilders.idsQuery().addIds(idsArray));
    SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder().query(bqb);
    searchRequest.source(searchSourceBuilder);
    try {
      SearchResponse searchResponse = rhlClient.search(searchRequest);
      List<E> list = Arrays.stream(searchResponse.getHits().getHits()).map(this::convert).collect(Collectors.toList());
      return list.stream().collect(Collectors.toMap(this::getDocumentId, Function.identity()));
    } catch (Exception e) {
      e.printStackTrace();
    }
    return Collections.emptyMap();
  }

6. 批量操作数据，里面可以包含添加更新删除等操作。

 BulkRequest bulkRequest = new BulkRequest();
                    infos.forEach(info -> {
                        IndexRequest indexRequest = new IndexRequest(index, type, info.getOrderId());
                        indexRequest.source(resultMap(info));
                        bulkRequest.add(indexRequest);
                    });
                    rhlClient.bulk(bulkRequest);

7. 简单查询

 SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

 // where
TermQueryBuilder queryBuilder = QueryBuilders.termQuery(name, value);
            boolQueryBuilder.must(queryBuilder);
 // 模糊
    WildcardQueryBuilder queryBuilder = QueryBuilders.wildcardQuery(name, "*" + value + "*");
            boolQueryBuilder.must(queryBuilder);
// in
   TermsQueryBuilder queryBuilder = QueryBuilders.termsQuery(name, value);
            boolQueryBuilder.must(queryBuilder);
// 范围
 RangeQueryBuilder queryBuilder = QueryBuilders.rangeQuery(name).gte(startTime.getTime()).lt(endTime.getTime());
            boolQueryBuilder.filter(queryBuilder);

 sort(searchSourceBuilder, "payDatetime", SortOrder.DESC);
 // 排序
    private void sort(SearchSourceBuilder searchSourceBuilder, String name, SortOrder order) {
        searchSourceBuilder.sort(new FieldSortBuilder(name).order(order));
    }

 // 分页
        searchSourceBuilder.from(page * size).size(size);

        // 查询语句
        searchSourceBuilder.query(boolQueryBuilder);

SearchResponse searchResponse = rhlClient.search(searchRequest.source(searchSourceBuilder), new BasicHeader("Content-Type", "application/json;charset=utf-8"));
            SearchHits hits = searchResponse.getHits();
            List<T> result = Arrays.stream(hits.getHits()).map(m -> JsonUtils.fromJson(m.getSourceAsString(), resultClass)).collect(Collectors.toList());

8. 聚合查询

原生es语句：
{
	"query": {
		"bool": {
			"must": [{
				"term": {
					"orderId": ""
				}
			}],
			"filter": [{
				"range": {
					"payDatetime": {
						"gte": 1551860000000,
						"lte": 1551861111111
					}
				}
			}]
		}
	},
	"aggs": {
		"groupPayDate": {
			"date_histogram": {
				"field": "payDatetime",
				"interval": "1d",
				"format": "yyyy-MM-dd HH:mm:ss",
				"time_zone": "+08:00",
				"order": {
					"_key": "desc"
				}
			},
			"aggs": {
				"having": {
					"bucket_selector": {
						"buckets_path": {
							"dayCount": "_count"
						},
						"script": "params.dayCount > 0"
					}
				},
				"groupDeliveryId": {
					"terms": {
						"field": "deliveryId",
						"size": 1000
					},
					"aggs": {
						"payPrice": {
							"sum": {
								"field": "payPrice"
							}
						},
						"PAY_AMOUNT_BUCKET_SORT": {
							"bucket_sort": {
								"sort": [{
									"_count": {
										"order": "desc"
									}
								}]
							}
						}
					}
				}
			}
		}
	},
	"size": 0
}

Java代码

  SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
        BoolQueryBuilder boolQueryBuilder = QueryBuilders.boolQuery();

 // 声明BucketPath，用于后面的bucket筛选
        Map<String, String> bucketsPathsMap = new HashMap<>(1, 1);
        bucketsPathsMap.put("dayCount", "_count");
        // 设置脚本
        Script script = new Script("params.dayCount > 0");
        // 构建bucket选择器
        BucketSelectorPipelineAggregationBuilder bs = PipelineAggregatorBuilders.bucketSelector("having", bucketsPathsMap, script);
        // 创建第一层聚合
        DateHistogramAggregationBuilder builder = AggregationBuilders.dateHistogram("groupPayDate").field("payDatetime").dateHistogramInterval(DateHistogramInterval.DAY)
                .format("yyyy-MM-dd HH:mm:ss").timeZone(DateTimeZone.forID("+08:00")).order(BucketOrder.key(false));
        builder.subAggregation(bs);
        // 创建第二层聚合
        TermsAggregationBuilder ts = AggregationBuilders.terms("groupDeliveryId").field("deliveryId").size(1000);
        // 创建第三层聚合
        SumAggregationBuilder ss = AggregationBuilders.sum("payPrice").field("payPrice");
        ts.subAggregation(ss);
        // 对第二层聚合数据进行排序
        ts.order(BucketOrder.aggregation("payPrice", false));
        builder.subAggregation(ts);

        // 查询语句
        searchSourceBuilder.query(boolQueryBuilder).aggregation(builder).size(0);

SearchResponse searchResponse = rhlClient.search(searchRequest.source(searchSourceBuilder), new BasicHeader("Content-Type", "application/json;charset=utf-8"));


ParsedDateHistogram parsedDateHistogram = searchResponse.getAggregations().get("groupPayDate");
        List<ParsedDateHistogram.ParsedBucket> buckets = (List<ParsedDateHistogram.ParsedBucket>) parsedDateHistogram.getBuckets();


for (int i = 0 i < buckets.size(); i++) {
            ParsedDateHistogram.ParsedBucket bucket = buckets.get(i);
            long timestamp = (Long) bucket.getKey();
            ParsedLongTerms lt = bucket.getAggregations().get("groupDeliveryId");
            List<ParsedLongTerms.ParsedBucket> bucketList = (List<ParsedLongTerms.ParsedBucket>) lt.getBuckets();
            for (ParsedLongTerms.ParsedBucket item : bucketList) {
                long deliveryId = item.getKey();
                    long payAmount = item.getDocCount();
                    ParsedSum ia = item.getAggregations().get("payPrice");
                    long payPrice = ia.getValue();
            }
        }

9. 当字符串设置类型为keyword时有可能因为长度太长报错，这个时候如果真想存储该字段的话可以用text类型。

ava.lang.IllegalArgumentException: Document contains at least one immense term in field="orderId" 
(whose UTF8 encoding is longer than the max length 32766), all of which were skipped.  Please correct the analyzer 
to not produce such terms.  The prefix of the first immense term is: '[]...', original message: bytes can be at most 
32766 in length; got 102464