您的位置：首页 > 编程语言 > Java开发

ElasticSearch JAVA API

2019-03-04 22:09 169 查看

Java API

pom.xml

org.elasticsearch.client:elasticsearch-rest-client
org.elasticsearch:elasticsearch

<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>
<version>6.5.4</version>
</dependency>
<dependency>
<groupId>org.apache.logging.log4j</groupId>
<artifactId>log4j-core</artifactId>
<version>2.11.1</version>
</dependency>

初始化

RestHighLevelClient client = new RestHighLevelClient(
RestClient.builder(
new HttpHost("localhost", 9200, "http"),
new HttpHost("localhost", 9201, "http")));

client.close();

Index API

// 1: 创建索引对象
IndexRequest request = new IndexRequest(/* index */"pazi",/* type */"test",/* id */"2");

// 2: 构建文件源,主要分为四类
/*
*      String类型
*/
String jsonString = "{" +
"\"user\":\"kimchy\"," +
"\"postDate\":\"2013-01-30\"," +
"\"message\":\"trying out Elasticsearch\"" +
"}";
request.source(jsonString, XContentType.JSON);
/*
*      Map类型
*/
Map<String, Object> jsonMap = new HashMap<>();
jsonMap.put("user", "kimchy");
jsonMap.put("postDate", new Date());
jsonMap.put("message", "trying out Elasticsearch");
IndexRequest indexRequest = new IndexRequest("posts", "doc", "1")
.source(jsonMap);
/*
*      XContentBuilder对象
*/
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
{
builder.field("user", "kimchy");
builder.timeField("postDate", new Date());
builder.field("message", "trying out Elasticsearch");
}
builder.endObject();
IndexRequest indexRequest = new IndexRequest("posts", "doc", "1")
.source(builder);
/*
*      Object键对
*/
IndexRequest indexRequest = new IndexRequest("posts", "doc", "1")
.source("user", "kimchy",
"postDate", new Date(),
"message", "trying out Elasticsearch");
// 在request后面可追加的一些参数
request.timeout("1s");  // 超时等待
request.version(2);     // 版本
request.versionType(VersionType.EXTERNAL);  //版本类型
request.setPipeline("pipeline");    // 操作类型
request.setRefreshPolicy(WriteRequest.RefreshPolicy.WAIT_UNTIL);
request.setRefreshPolicy("wait_for");   // 刷新策略

// 3: 执行,主要分为同步和异步执行,一般使用同步
IndexResponse indexResponse = client.index(request, RequestOptions.DEFAULT);

// 4: 执行返回结果
String index = indexResponse.getIndex();
String type = indexResponse.getType();
String id = indexResponse.getId();
long version = indexResponse.getVersion();
if (indexResponse.getResult() == DocWriteResponse.Result.CREATED) {
// 第一次创建文档返回得状态
} else if (indexResponse.getResult() == DocWriteResponse.Result.UPDATED) {
// 这个是update得情况
}
ReplicationResponse.ShardInfo shardInfo = indexResponse.getShardInfo();
if (shardInfo.getTotal() != shardInfo.getSuccessful()) {
// 处理得分片状态
}
// 这个是处理数据 分片出错得信息
if (shardInfo.getFailed() > 0) {
for (ReplicationResponse.ShardInfo.Failure failure :
shardInfo.getFailures()) {
String reason = failure.reason();
}
}

// 5: 存在的异常信息
IndexRequest request = new IndexRequest("posts", "doc", "1")
.source("field", "value")
.version(1)  // 引发的异常指示返回版本冲突错误
.opType(DocWriteRequest.OpType.CREATE);  // 引发创建出错的信息,在创建时候不指定id一般回避免
try {
IndexResponse response = client.index(request, RequestOptions.DEFAULT);
} catch(ElasticsearchException e) {
if (e.status() == RestStatus.CONFLICT) {

}
}

GET API

// 1: 获取GET对象
GetRequest getRequest = new GetRequest(/*index*/"pazi", /*type*/"test", /*id*/"1");

// 2. GET对象可选参数
//禁用源检索，默认启用
request.fetchSourceContext(FetchSourceContext.DO_NOT_FETCH_SOURCE);
// 为特定字段配置源包含
String[] includes = new String[]{"message", "*Date"};
String[] excludes = Strings.EMPTY_ARRAY;
FetchSourceContext fetchSourceContext =
new FetchSourceContext(true, includes, excludes);
request.fetchSourceContext(fetchSourceContext);
request.routing("routing");     // 路由值
request.parent("parent");       // 父值
request.preference("preference");// 偏好值
request.realtime(false);        // 将实时标志设置为false (true在默认情况下)
request.refresh(true);          // 在检索文档之前执行刷新(false在默认情况下)
request.version(2)              // 版本
request.versionType(VersionType.EXTERNAL); // 版本类型

// 3: 执行,此处记录同步执行
GetResponse getResponse = client.get(getRequest, RequestOptions.DEFAULT);

// 4: 返回结果
String index = getResponse.getIndex();
String type = getResponse.getType();
String id = getResponse.getId();
if (getResponse.isExists()) {
long version = getResponse.getVersion();
// 讲结果转成string
String sourceAsString = getResponse.getSourceAsString();
Map<String, Object> sourceAsMap = getResponse.getSourceAsMap();
byte[] sourceAsBytes = getResponse.getSourceAsBytes();
} else {
// 如果不存在应该添加捕获异常处理
}

// 5: 异常处理
GetRequest request = new GetRequest("does_not_exist", "doc", "1");
try {
GetResponse getResponse = client.get(request, RequestOptions.DEFAULT);
} catch (ElasticsearchException e) {
if (e.status() == RestStatus.NOT_FOUND) {
// 如果文档不存在进行操作
}
}
// 还有一个version版本问题,同上.

判断是否存在 API

// 1: 获取GET对象
GetRequest getRequest = new GetRequest(/*index*/"pazi", /*type*/"test", /*id*/"1");
// 2: 添加参数
// 不取"_source"
getRequest.fetchSourceContext(new FetchSourceContext(false));
// 禁用获取存储字段
getRequest.storedFields("_none_");
// 3: 执行
boolean exists = client.exists(getRequest, RequestOptions.DEFAULT);

DELETE API

// 1: 创建删除对象
DeleteRequest deleteRequest = new DeleteRequest(/*index*/"pazi", /*type*/"test", /*id*/"1");

// 2: 执行
DeleteResponse deleteResponse = client.delete(deleteRequest, RequestOptions.DEFAULT);

// 3: 附加参数如上

// 4: 返回参数
String index = deleteResponse.getIndex();
String type = deleteResponse.getType();
String id = deleteResponse.getId();
long version = deleteResponse.getVersion();
ReplicationResponse.ShardInfo shardInfo = deleteResponse.getShardInfo();
if (shardInfo.getTotal() != shardInfo.getSuccessful()) {

}
if (shardInfo.getFailed() > 0) {
for (ReplicationResponse.ShardInfo.Failure failure :
shardInfo.getFailures()) {
String reason = failure.reason();
}
}

// 5: 异常
DeleteRequest request = new DeleteRequest("posts", "doc", "does_not_exist");
DeleteResponse deleteResponse = client.delete(
request, RequestOptions.DEFAULT);
if (deleteResponse.getResult() == DocWriteResponse.Result.NOT_FOUND) {
// 不存在
}

UPDATE API

// 1: 创建更新对象
UpdateRequest updateRequest = new UpdateRequest(/*index*/"pazi", /*type*/"test", /*id*/"1");

// 2: 创建数据源方法与Index API 相像,只列举一种,只有最后面的`source`替换为`doc`
// Object 对象
UpdateRequest request = new UpdateRequest("posts", "doc", "1")
.doc("updated", new Date(),
"reason", "daily update");

// 3: upsert操作,如果文档不存在，则可以使用upsert方法
String jsonString = "{\"created\":\"2017-01-01\"}";
request.upsert(jsonString, XContentType.JSON);

// 4: 可选参数
// 如果要更新的文档在更新操作的GET和索引阶段之间被另一个操作更改，那么要重试更新操作多少次？
request.retryOnConflict(3);
request.detectNoop(false);      // 禁用noop检测
// 指示脚本必须运行，无论文档是否存在(如果文档不存在，脚本负责创建文档)。
request.scriptedUpsert(true);
// 指示如果部分文档尚不存在，则必须将其用作上插入文档。
request.docAsUpsert(true);
// 	设置在执行更新操作之前必须处于活动状态的碎片副本的数量。
request.waitForActiveShards(2);
request.waitForActiveShards(ActiveShardCount.ALL);

// 5: 执行
UpdateResponse updateResponse = client.update(request, RequestOptions.DEFAULT);

// 6: 参数相应
String index = updateResponse.getIndex();
String type = updateResponse.getType();
String id = updateResponse.getId();
long version = updateResponse.getVersion();
if (updateResponse.getResult() == DocWriteResponse.Result.CREATED) {

} else if (updateResponse.getResult() == DocWriteResponse.Result.UPDATED) {

} else if (updateResponse.getResult() == DocWriteResponse.Result.DELETED) {

} else if (updateResponse.getResult() == DocWriteResponse.Result.NOOP) {

}
// 返回结果
GetResult result = updateResponse.getGetResult();
if (result.isExists()) {
String sourceAsString = result.sourceAsString();
Map<String, Object> sourceAsMap = result.sourceAsMap();
byte[] sourceAsBytes = result.source();
} else {

}
// 碎片状态
ReplicationResponse.ShardInfo shardInfo = updateResponse.getShardInfo();
if (shardInfo.getTotal() != shardInfo.getSuccessful()) {

}
if (shardInfo.getFailed() > 0) {
for (ReplicationResponse.ShardInfo.Failure failure :
shardInfo.getFailures()) {
String reason = failure.reason();
}
}

// 7: 异常
if (e.status() == RestStatus.NOT_FOUND) {
// 不存在
}

BULK API

批量操作(PUT,POST,DELETE) API

// 1: 构建BULK操作对象
BulkRequest bulkRequest = new BulkRequest();

// 2: 添加批量操作对象 ...
bulkRequest.add(new DeleteRequest());
bulkRequest.add(new UpdateRequest());

// 3: 配置可选参数
bulkRequest.timeout("2s"); // 超时
bulkRequest.setRefreshPolicy("wait_for"); // 刷新策略
bulkRequest.waitForActiveShards(2); // 分片存活数量

// 4: 执行
BulkResponse bulkResponse = client.bulk(bulkRequest, RequestOptions.DEFAULT);

// 5: 解析返回结果
// 如果至少有一次操作失败,此方法返回true
boolean hasFailures = bulkResponse.hasFailures();
// 返回的是每个操作的单独结果
for (BulkItemResponse bulkItemResponse : bulkResponse) {

// 检索操作的响应
DocWriteResponse itemResponse = bulkItemResponse.getResponse();
// 是否成功
boolean failed = bulkItemResponse.isFailed();

if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.INDEX
|| bulkItemResponse.getOpType() == DocWriteRequest.OpType.CREATE) {
IndexResponse indexResponse = (IndexResponse) itemResponse;

} else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.UPDATE) {
UpdateResponse updateResponse = (UpdateResponse) itemResponse;

} else if (bulkItemResponse.getOpType() == DocWriteRequest.OpType.DELETE) {
DeleteResponse deleteResponse = (DeleteResponse) itemResponse;
}
}

MultGet API

批量获取GEt请求

// 1: 创建MultGet对象
MultiGetRequest multiGetRequest = new MultiGetRequest();
multiGetRequest.add(new Item("pazi", "test", "1"));
multiGetRequest.add(new Item("pazi", "test", "2"));

// 2: 参数设置,参考GET操作

// 3: 执行
MultiGetResponse mget = client.mget(multiGetRequest, RequestOptions.DEFAULT);

// 4: 解析参数
for (MultiGetItemResponse multiGetItemResponse : mget) {
System.out.println(multiGetItemResponse.getFailure());
System.out.println(multiGetItemResponse.getId());
GetResponse response = multiGetItemResponse.getResponse();
boolean exists = response.isExists();
System.out.println(exists);
}

ReindexRequest API

可用于将文档从一个或多个索引复制到目标索引中。

// 1: 创建Reindex操作对象
ReindexRequest reindexRequest = new ReindexRequest();

// 2: 设置目标源与原数据源
reindexRequest.setSourceIndices("pazi");
reindexRequest.setDestIndex("mmmli");

// 3: 设置参数,https://www.elastic.co/guide/en/elasticsearch/client/java-rest/6.5/java-rest-high-document-reindex.html
reindexRequest.setSourceDocTypes("test"); // 目标类型

// 4: 执行
BulkByScrollResponse bulkResponse = client.reindex(reindexRequest, RequestOptions.DEFAULT);

// 5: 相应结果
// 总时间
TimeValue timeTaken = bulkResponse.getTook();
// 是否超时
boolean timedOut = bulkResponse.isTimedOut();
// 处理的文档总数
long totalDocs = bulkResponse.getTotal();
// 已更新的文档数量
long updatedDocs = bulkResponse.getUpdated();
// 创建的文档数量
long createdDocs = bulkResponse.getCreated();
// 被删除的文档数量
long deletedDocs = bulkResponse.getDeleted();
// 执行的批次
long batches = bulkResponse.getBatches();
// 跳过的文档书
long noops = bulkResponse.getNoops();
// 版本冲突次数
long versionConflicts = bulkResponse.getVersionConflicts();
// 	请求重试大容量索引操作的次数
long bulkRetries = bulkResponse.getBulkRetries();
// 请求重试搜索操作的次数
long searchRetries = bulkResponse.getSearchRetries();
// 如果该请求当前处于休眠状态，则不包括当前节流阀时间。
TimeValue throttledMillis = bulkResponse.getStatus().getThrottled();
// 任何当前节流阀睡眠的剩余延迟，如果没有睡眠，则为0
TimeValue throttledUntilMillis = bulkResponse.getStatus().getThrottledUntil();
// 搜索阶段的故障
List<ScrollableHitSource.SearchFailure> searchFailures = bulkResponse.getSearchFailures();
// 大容量索引操作中的故障
List<BulkItemResponse.Failure> bulkFailures = bulkResponse.getBulkFailures();

System.out.println(timeTaken + "-" + timedOut + "-" + totalDocs + "-" + updatedDocs + "-" + createdDocs + "-" + deletedDocs);

Update By Query API

// 1: 创建对象
UpdateByQueryRequest updateByQueryRequest = new UpdateByQueryRequest("source1", "source2");

// 2: 执行
BulkByScrollResponse updateByQuery = client.updateByQuery(updateByQueryRequest, RequestOptions.DEFAULT);

// 3: 处理返回结果同上

Search Data API

// 1: 获取Search请求对象
SearchRequest searchRequest = new SearchRequest();
searchRequest.indices("mmmli");		// 指定index
searchRequest.types("test");		// 指定type

// 2: 获取查询体对象,并添加查询内容
// 2.1: SearchSourceBuilder
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchAllQuery());
searchSourceBuilder.from(0); // 页码
searchSourceBuilder.size(10); // 每页条数
// 2.2: MatchQueryBuilder
MatchQueryBuilder matchQueryBuilder = new MatchQueryBuilder("name", "刘奉英");
matchQueryBuilder.fuzziness(Fuzziness.AUTO); // 启动模糊查询
matchQueryBuilder.prefixLength(3); // 在匹配查询上设置前缀长度选项
matchQueryBuilder.maxExpansions(10); // 设置最大展开选项以控制查询的模糊过程
// 2.3 QueryBuilders --> QueryBuilder
QueryBuilder queryBuilder = QueryBuilders.matchQuery("name", "刘奉英").fuzziness(Fuzziness.AUTO).prefixLength(3)
.maxExpansions(10);
// --------------------
// 以上种种方法,都是为了创建一个查询体对象用来构建查询条件已完成查询.最后都要添加到请求对象中.
// --------------------
// 对查询体对象添加过滤条件
// 排序
// searchSourceBuilder.sort(new ScoreSortBuilder().order(SortOrder.DESC));
// searchSourceBuilder.sort(new FieldSortBuilder("_id").order(SortOrder.ASC));
// 滤波,过滤掉指定字段
// searchSourceBuilder.fetchSource(false);	//_source 字段过滤掉
// searchSourceBuilder.fetchSource(new String[] {"name"}, new String[]{"_type"}); // 保留 name 字段 过滤 _type字段
// 高亮
// 		略
// 聚合
// TermsAggregationBuilder aggregationBuilder = AggregationBuilders.terms("username").field("name");
// aggregationBuilder.subAggregation(AggregationBuilders.avg("age_avg")).field("age");
// searchSourceBuilder.aggregation(aggregationBuilder);

// 3: 查询体对象添加到请求对象中
searchRequest.source(searchSourceBuilder);

// 4: 执行
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

// 5: 返回结果分析
// 状态
RestStatus status = searchResponse.status();
// 时间
TimeValue took = searchResponse.getTook();
// 是否超时
boolean timedOut = searchResponse.isTimedOut();
// 执行的分片信息
int totalShards = searchResponse.getTotalShards();
int failedShards = searchResponse.getFailedShards();
int successfulShards = searchResponse.getSuccessfulShards();
ShardSearchFailure[] shardFailures = searchResponse.getShardFailures();
// 获取返回的Hits信息
SearchHits hits = searchResponse.getHits();
// 获取maxScore以及totalHits
long totalHits = hits.getTotalHits();
float maxScore = hits.getMaxScore();
System.out.println(totalHits);
// 搜索结果
SearchHit[] searchHits = hits.getHits();
// 遍历搜索结果集
for (SearchHit searchHit : searchHits) {
// index,type,id,score
String index = searchHit.getIndex();
// 获取文档源转换
String sourceAsString = searchHit.getSourceAsString();
// 转成map进一步获取属性
Map<String, Object> sourceAsMap = searchHit.getSourceAsMap();
System.out.println(index);
}

// 获取聚合信息
// Aggregations aggregations = searchResponse.getAggregations();
// Terms usTerms= aggregations.get("username");
// 此处还有Range聚合等等
// 获取子聚合信息
// Bucket bucketByKey = usTerms.getBucketByKey("Elastic");
// Avg aggregation = bucketByKey.getAggregations().get("age_avg");
// double value = aggregation.getValue();
// System.out.println(value);

// 还有许许多多 此处省略..
// https://www.elastic.co/guide/en/elasticsearch/client/java-rest/6.5/java-rest-high-search.html

Search Scroll API

Scroll API可用于从搜索请求中检索大量结果。

// 1:  构建查询请求
SearchRequest searchRequest = new SearchRequest("mmmli").types("test");

// 2: 构建查询体对象
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchAllQuery());
searchSourceBuilder.from(0);
searchSourceBuilder.size(10);

// 3: 将查询体对象添加到查询请求中
searchRequest.source(searchSourceBuilder);
// 设置滚动间隔
final Scroll scroll = new Scroll(TimeValue.timeValueMinutes(1L));
searchRequest.scroll(scroll);

// 4: 执行查询
SearchResponse searchResponse = client.search(searchRequest, RequestOptions.DEFAULT);

// 5: 响应体
// 读取返回的滚动ID，它指向正在保持活动的搜索上下文，在下面的搜索滚动调用中将需要该上下文
String scrollId = searchResponse.getScrollId();
// 第一批搜索结果
SearchHit[] searchHits = searchResponse.getHits().getHits();
// 判断是否获取完毕
while(searchHits != null && searchHits.length > 0) {
// 6: 创建滚动请求体
SearchScrollRequest scrollRequest = new SearchScrollRequest(scrollId);
scrollRequest.scroll(scroll);

// 7: 获取第二批数据
SearchResponse scrollResponse = client.scroll(scrollRequest, RequestOptions.DEFAULT);

// 8: 响应体
String scrollId2 = scrollResponse.getScrollId();
SearchHits hits2 = scrollResponse.getHits();
// 自定义逻辑...
}

// 9: 获取完毕之后,清除
// 创建清楚请求体
ClearScrollRequest clearScrollRequest = new ClearScrollRequest();
// 添加清楚ID
clearScrollRequest.addScrollId(scrollId);
// 执行
ClearScrollResponse clearScroll = client.clearScroll(clearScrollRequest, RequestOptions.DEFAULT);
// 判断以及成功数量
boolean succeeded = clearScroll.isSucceeded();
int numFreed = clearScroll.getNumFreed();

MultSearch API

// 1: 多条查询构建请求体
MultiSearchRequest multiSearchRequest = new MultiSearchRequest();

// 2: 创建第一个查询体以及查询内容添加到多查询体中
SearchRequest firstSearchRequest = new SearchRequest("mmmli").types("test");
SearchSourceBuilder searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchQuery("name", "刘奉英"));
firstSearchRequest.source(searchSourceBuilder);
multiSearchRequest.add(firstSearchRequest);

// 3: 创建第二个
SearchRequest secondSearchRequest = new SearchRequest("mmmli").types("test");
searchSourceBuilder = new SearchSourceBuilder();
searchSourceBuilder.query(QueryBuilders.matchQuery("sex", "男"));
secondSearchRequest.source(searchSourceBuilder);
multiSearchRequest.add(secondSearchRequest);

// 4: 执行
MultiSearchResponse multiSearchResponse = client.msearch(multiSearchRequest, RequestOptions.DEFAULT);

// 5: 响应体
org.elasticsearch.action.search.MultiSearchResponse.Item[] responses = multiSearchResponse.getResponses();
for (org.elasticsearch.action.search.MultiSearchResponse.Item item : responses) {
SearchResponse response = item.getResponse();
// 获取返回的数据
}

Info API

// 1: 执行info方法
MainResponse response = client.info(RequestOptions.DEFAULT);

// 2: 解析响应体
// 集群名称
ClusterName clusterName = response.getClusterName();
// 集群ID
String clusterUuid = response.getClusterUuid();
// 当前节点名称
String nodeName = response.getNodeName();
// 节点版本
Version version = response.getVersion();
// 检索请求已在其上执行的节点的生成信息。
Build build = response.getBuild();

Ping API

检查集群是否已启动并可用于处理请求，并返回布尔值

boolean response = client.ping(RequestOptions.DEFAULT);

Index API

一般索引什么的都由shell语句创建,很少通过JAVA API来操作,稍微记录一下.

Create Index

// 1: 构建Index请求体
CreateIndexRequest request = new CreateIndexRequest("twitter");

// 2: index设置
request.settings(Settings.builder()
.put("index.number_of_shards", 3)
.put("index.number_of_replicas", 2)
);

// 3: index Mapping设置,分为三种方法.
// 3.1
request.mapping("_doc",
"{\n" +
"  \"_doc\": {\n" +
"    \"properties\": {\n" +
"      \"message\": {\n" +
"        \"type\": \"text\"\n" +
"      }\n" +
"    }\n" +
"  }\n" +
"}",
XContentType.JSON);
// 3.2
Map<String, Object> jsonMap = new HashMap<>();
Map<String, Object> message = new HashMap<>();
message.put("type", "text");
Map<String, Object> properties = new HashMap<>();
properties.put("message", message);
Map<String, Object> mapping = new HashMap<>();
mapping.put("properties", properties);
jsonMap.put("_doc", mapping);
request.mapping("_doc", jsonMap);
// 3.3
XContentBuilder builder = XContentFactory.jsonBuilder();
builder.startObject();
{
builder.startObject("_doc");
{
builder.startObject("properties");
{
builder.startObject("message");
{
builder.field("type", "text");
}
builder.endObject();
}
builder.endObject();
}
builder.endObject();
}
builder.endObject();
request.mapping("_doc", builder);

// 4: 执行
CreateIndexResponse createIndexResponse = client.indices().create(request, RequestOptions.DEFAULT);

// 5: 响应
// 	指示是否所有节点都已确认请求
boolean acknowledged = createIndexResponse.isAcknowledged();
// 是否在超时之前为索引中的每个碎片启动了所需数量的碎片副本
boolean shardsAcknowledged = createIndexResponse.isShardsAcknowledged();

Delete Index API

// 1: 构建删除请求体
DeleteIndexRequest request = new DeleteIndexRequest("posts");

// 2: 执行
AcknowledgedResponse deleteIndexResponse = client.indices().delete(request, RequestOptions.DEFAULT);

// 3: 响应
boolean acknowledged = deleteIndexResponse.isAcknowledged();

Exist index API

// 1: 构建响应体
GetIndexRequest request = new GetIndexRequest();
request.indices("twitter"); // 设置索引

// 2: 执行
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);

// 3: 响应
boolean exists = client.indices().exists(request, RequestOptions.DEFAULT);

Open and Close Index

// 1: 构建
OpenIndexRequest request = new OpenIndexRequest("index");
CloseIndexRequest request = new CloseIndexRequest("index");

// 2 : 执行
OpenIndexResponse openIndexResponse = client.indices().open(request, RequestOptions.DEFAULT);
AcknowledgedResponse closeIndexResponse = client.indices().close(request, RequestOptions.DEFAULT);

// 3: 响应
boolean acknowledged = /*close*/openIndexResponse.isAcknowledged();

GEt Index API

// 1: 构建请求体
GetIndexRequest request = new GetIndexRequest().indices("index");

// 2: 执行
GetIndexResponse getIndexResponse = client.indices().get(request, RequestOptions.DEFAULT);

// 3: 获取响应
ImmutableOpenMap<String, MappingMetaData> indexMappings = getIndexResponse.getMappings().get("index");
Map<String, Object> indexTypeMappings = indexMappings.get("doc").getSourceAsMap();
List<AliasMetaData> indexAliases = getIndexResponse.getAliases().get("index");
String numberOfShardsString = getIndexResponse.getSetting("index", "index.number_of_shards");
Settings indexSettings = getIndexResponse.getSettings().get("index");
Integer numberOfShards = indexSettings.getAsInt("index.number_of_shards", null);
TimeValue time = getIndexResponse.defaultSettings().get("index")
.getAsTime("index.refresh_interval", null);

刷新 Index API

refresh: 将数据从内存刷新到磁盘
flush: 将数据落盘

// 1: 构建
// 参数为空的时候,刷新全部.
RefreshRequest requestAll = new RefreshRequest(/*"index1", "index2"*/);
FlushRequest requestMultiple = new FlushRequest(/*"index1", "index2"*/);

// 2: 执行
RefreshResponse refreshResponse = client.indices().refresh(request, RequestOptions.DEFAULT);
FlushResponse flushResponse = client.indices().flush(request, RequestOptions.DEFAULT);

// 3: 响应
// 请求全部的分片数
int totalShards = refreshResponse.getTotalShards();
// 成功的
int successfulShards = refreshResponse.getSuccessfulShards();
// 失败的
int failedShards = refreshResponse.getFailedShards();
// 故障列表
DefaultShardOperationFailedException[] failures = refreshResponse.getShardFailures();

// 4: 异常
try {
FlushRequest request = new FlushRequest("does_not_exist");
client.indices().flush(request, RequestOptions.DEFAULT);
} catch (ElasticsearchException exception) {
if (exception.status() == RestStatus.NOT_FOUND) {

}
}

查询构建器

搜索查询	QueryBuilder类	QueryBuilders中的方法
匹配所有	MatchAllQueryBuilder	QueryBuilders.MediaAllQuery()
匹配	MatchQueryBuilder	QueryBuilders.mediQuery()
匹配短语	MatchPhraseQueryBuilder	QueryBuilders.mediphraseQuery()
匹配短语前缀	MatchPhrasePrefix QueryBuilder	QueryBuilders.mediphrasePrefix Query()
多匹配	MultiMatchQueryBuilder	QueryBuilders.multiMatchQuery()
共同术语	CommonTermsQueryBuilder	QueryBuilders.CommonTermsQuery()
查询字符串	QueryStringQueryBuilder	QueryBuilders.queryStringQuery()
简单查询字符串	SimpleQueryStringBuilder	QueryBuilders.simpleQueryStringQuery()
术语	TermQueryBuilder	QueryBuilders.TerQuery()
条款	TermsQueryBuilder	QueryBuilders.TersQuery()
范围	RangeQueryBuilder	QueryBuilders.rangeQuery()
存在	ExistsQueryBuilder	QueryBuilders.live sQuery()
前缀	PrefixQueryBuilder	PrefixQuery()
雷吉普	RegexpQueryBuilder	QueryBuilders.regexpQuery()
模糊	FuzzyQueryBuilder	QueryBuilders.FuzzyQuery()
类型	TypeQueryBuilder	QueryBuilders.typeQuery()
ID	IdsQueryBuilder	QueryBuilders.idsQuery()
恒定分数	ConstantScoreQueryBuilder	QueryBuilders.constantScoreQuery()
布尔	BoolQueryBuilder	QueryBuilders.boolQuery()
功能评分	FunctionScoreQueryBuilder	QueryBuilders.FunctionScoreQuery()
助推	BoostingQueryBuilder	queryBuilders.bostingQuery()

内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理

标签：

相关文章推荐

新的分享

章节导航