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() |