Cwikius-Spring/spring-data-elasticsearch
1
0
Fork 0
mirror of https://github.com/spring-projects/spring-data-elasticsearch.git synced 2025-05-30 16:52:11 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove TransportClient.

Browse Source 
Original Pull Request #1992 
Closes #1958
This commit is contained in:
Peter-Josef Meisch 2021-11-12 20:33:29 +01:00 committed by GitHub
parent 35c608b546
commit 0b4c5b4155
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
132 changed files with 526 additions and 3563 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
README.adoc
View File

@ -4,14 +4,16 @@ image:https://spring.io/badges/spring-data-elasticsearch/ga.svg[Spring Data Elas
The primary goal of the https://projects.spring.io/spring-data[Spring Data] project is to make it easier to build Spring-powered applications that use new data access technologies such as non-relational databases, map-reduce frameworks, and cloud based data services.
The Spring Data Elasticsearch project provides integration with the https://www.elastic.co/[Elasticsearch] search engine. Key functional areas of Spring Data Elasticsearch are a POJO centric model for interacting with a Elasticsearch Documents and easily writing a Repository style data access layer.
The Spring Data Elasticsearch project provides integration with the https://www.elastic.co/[Elasticsearch] search engine.
Key functional areas of Spring Data Elasticsearch are a POJO centric model for interacting with a Elasticsearch Documents and easily writing a Repository style data access layer.
This project is lead and maintained by the community.
== Features
* Spring configuration support using Java based `@Configuration` classes or an XML namespace for a ES clients instances.
* `ElasticsearchRestTemplate` helper class that increases productivity performing common ES operations. Includes integrated object mapping between documents and POJOs.
* `ElasticsearchRestTemplate` helper class that increases productivity performing common ES operations.
Includes integrated object mapping between documents and POJOs.
* Feature Rich Object Mapping integrated with Spring’s Conversion Service
* Annotation based mapping metadata
* Automatic implementation of `Repository` interfaces including support for custom search methods.
@ -19,7 +21,9 @@ This project is lead and maintained by the community.
== Code of Conduct
This project is governed by the https://github.com/spring-projects/.github/blob/e3cc2ff230d8f1dca06535aa6b5a4a23815861d4/CODE_OF_CONDUCT.md[Spring Code of Conduct]. By participating, you are expected to uphold this code of conduct. Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
This project is governed by the https://github.com/spring-projects/.github/blob/e3cc2ff230d8f1dca06535aa6b5a4a23815861d4/CODE_OF_CONDUCT.md[Spring Code of Conduct].
By participating, you are expected to uphold this code of conduct.
Please report unacceptable behavior to spring-code-of-conduct@pivotal.io.
== Getting Started
@ -58,31 +62,6 @@ public class MyService {
}
----
=== Using Transport Client
NOTE: Usage of the TransportClient is deprecated as of version 4.0, use RestClient instead.
[source,java]
----
@Configuration
public class TransportClientConfig extends ElasticsearchConfigurationSupport {
@Bean
public Client elasticsearchClient() throws UnknownHostException {
Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
TransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
return client;
}
@Bean(name = { "elasticsearchOperations", "elasticsearchTemplate" })
public ElasticsearchTemplate elasticsearchTemplate() throws UnknownHostException {
return new ElasticsearchTemplate(elasticsearchClient());
}
}
----
=== Using the RestClient
Provide a configuration like this:
@ -161,7 +140,8 @@ If you'd rather like the latest snapshots of the upcoming major version, use our
== Getting Help
Having trouble with Spring Data? We’d love to help!
Having trouble with Spring Data?
We’d love to help!
* Check the
https://docs.spring.io/spring-data/elasticsearch/docs/current/reference/html/[reference documentation], and https://docs.spring.io/spring-data/elasticsearch/docs/current/api/[Javadocs].
@ -174,14 +154,16 @@ You can also chat with the community on https://gitter.im/spring-projects/spring
== Reporting Issues
Spring Data uses GitHub as issue tracking system to record bugs and feature requests. If you want to raise an issue, please follow the recommendations below:
Spring Data uses GitHub as issue tracking system to record bugs and feature requests.
If you want to raise an issue, please follow the recommendations below:
* Before you log a bug, please search the
https://github.com/spring-projects/spring-data-elasticsearch/issues[issue tracker] to see if someone has already reported the problem.
* If the issue doesn’t already exist, https://github.com/spring-projects/spring-data-elasticsearch/issues/new[create a new issue].
* Please provide as much information as possible with the issue report, we like to know the version of Spring Data Elasticsearch that you are using and JVM version.
* If you need to paste code, or include a stack trace use Markdown +++```+++ escapes before and after your text.
* If possible try to create a test-case or project that replicates the issue. Attach a link to your code or a compressed file containing your code.
* If possible try to create a test-case or project that replicates the issue.
Attach a link to your code or a compressed file containing your code.
== Building from Source
@ -197,11 +179,8 @@ If you want to build with the regular `mvn` command, you will need https://maven
_Also see link:CONTRIBUTING.adoc[CONTRIBUTING.adoc] if you wish to submit pull requests, and in particular please sign the https://cla.pivotal.io/sign/spring[Contributor’s Agreement] before submitting your first pull request._
IMPORTANT: When contributing, please make sure an issue exists in https://github.com/spring-projects/spring-data-elasticsearch/issues[issue tracker] and comment on this issue with how you want to address it. By this we not only know that someone is working on an issue, we can also align architectural questions and possible solutions before work is invested
. We
so
can prevent that much work is put into Pull Requests that have little
or no chances of being merged.
IMPORTANT: When contributing, please make sure an issue exists in https://github.com/spring-projects/spring-data-elasticsearch/issues[issue tracker] and comment on this issue with how you want to address it.
By this we not only know that someone is working on an issue, we can also align architectural questions and possible solutions before work is invested . We so can prevent that much work is put into Pull Requests that have little or no chances of being merged.
=== Building reference documentation

19
pom.xml
View File

@ -101,12 +101,6 @@
<dependency>
<groupId>org.springframework</groupId>
<artifactId>spring-context</artifactId>
<exclusions>
<exclusion>
<groupId>commons-logging</groupId>
<artifactId>commons-logging</artifactId>
</exclusion>
</exclusions>
</dependency>
<dependency>
@ -141,19 +135,6 @@
</dependency>
<!-- Elasticsearch -->
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>transport</artifactId>
<version>${elasticsearch}</version>
</dependency>
<dependency>
<!-- required by elasticsearch -->
<groupId>org.elasticsearch.plugin</groupId>
<artifactId>transport-netty4-client</artifactId>
<version>${elasticsearch}</version>
</dependency>
<dependency>
<groupId>org.elasticsearch.client</groupId>
<artifactId>elasticsearch-rest-high-level-client</artifactId>

52
src/main/asciidoc/reference/elasticsearch-clients.adoc
View File

@ -6,58 +6,10 @@ This chapter illustrates configuration and usage of supported Elasticsearch clie
Spring Data Elasticsearch operates upon an Elasticsearch client that is connected to a single Elasticsearch node or a cluster.
Although the Elasticsearch Client can be used to work with the cluster, applications using Spring Data Elasticsearch normally use the higher level abstractions of <<elasticsearch.operations>> and <<elasticsearch.repositories>>.
[[elasticsearch.clients.transport]]
== Transport Client
WARNING: The `TransportClient` is deprecated as of Elasticsearch 7 and will be removed in Elasticsearch 8. (https://www.elastic.co/guide/en/elasticsearch/client/java-api/current/transport-client.html[see the Elasticsearch documentation]).
Spring Data Elasticsearch will support the `TransportClient` as long as it is available in the used Elasticsearch <<elasticsearch.versions,version>> but has deprecated the classes using it since version 4.0.
We strongly recommend to use the <<elasticsearch.clients.rest>> instead of the `TransportClient`.
.Transport Client
====
[source,java]
----
@Configuration
public class TransportClientConfig extends ElasticsearchConfigurationSupport {
@Bean
public Client elasticsearchClient() throws UnknownHostException {
Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build(); <.>
TransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300)); <.>
return client;
}
@Bean(name = { "elasticsearchOperations", "elasticsearchTemplate" })
public ElasticsearchTemplate elasticsearchTemplate() throws UnknownHostException {
ElasticsearchTemplate template = new ElasticsearchTemplate(elasticsearchClient, elasticsearchConverter);
template.setRefreshPolicy(refreshPolicy()); <.>
return template;
}
}
// ...
IndexRequest request = new IndexRequest("spring-data")
.id(randomID())
.source(someObject);
IndexResponse response = client.index(request);
----
<.> The `TransportClient` must be configured with the cluster name.
<.> The host and port to connect the client to.
<.> the RefreshPolicy must be set in the `ElasticsearchTemplate` (override `refreshPolicy()` to not use the default)
====
[[elasticsearch.clients.rest]]
== High Level REST Client
The Java High Level REST Client is the default client of Elasticsearch, it provides a straight forward replacement for the `TransportClient` as it accepts and returns the very same request/response objects and therefore depends on the Elasticsearch core project.
Asynchronous calls are operated upon a client managed thread pool and require a callback to be notified when the request is done.
The Java High Level REST Client is the default client of Elasticsearch, it is configured like shown:
.High Level REST Client
====
@ -210,4 +162,4 @@ To see what is actually sent to and received from the server `Request` / `Respon
<logger name="org.springframework.data.elasticsearch.client.WIRE" level="trace"/>
----
NOTE: The above applies to both the `RestHighLevelClient` and `ReactiveElasticsearchClient` when obtained via `RestClients` respectively `ReactiveRestClients`, is not available for the `TransportClient`.
NOTE: The above applies to both the `RestHighLevelClient` and `ReactiveElasticsearchClient` when obtained via `RestClients` respectively `ReactiveRestClients`.

9
src/main/asciidoc/reference/elasticsearch-migration-guide-4.3-4.4.adoc
View File

@ -12,3 +12,12 @@ This section describes breaking changes from version 4.3.x to 4.4.x and how remo
=== Package changes
* The package `org.springframework.data.elasticsearch.core.clients.elasticsearch7` has been renamed to `org.springframework.data.elasticsearch.core.backend.elasticsearch7`.
=== Removal of deprecated classes
==== `ElasticsearchTemplate` has been removed
As of version 4.4 Spring Data Elasticsearch does not use the `TransportClient` from Elasticsearch anymore (which itself is deprecated since Elasticsearch 7.0).
This means that the `ElasticsearchTemplate` class which was deprecated since Spring Data Elasticsearch 4.0 has been removed.
This was the implementation of the `ElasticsearchOperations` interface that was using the `TransportClient`.
Connections to Elasticsearch must be made using either the imperative `ElasticsearchRestTemplate` or the reactive `ReactiveElasticsearchTemplate`.

34
src/main/asciidoc/reference/elasticsearch-operations.adoc
View File

@ -30,40 +30,6 @@ There is support for automatic creation of indices and writing the mappings when
====
[[elasticsearch.operations.template]]
== ElasticsearchTemplate
NOTE: Usage of the ElasticsearchTemplate is deprecated as of version 4.0, use ElasticsearchRestTemplate instead.
The `ElasticsearchTemplate` is an implementation of the `ElasticsearchOperations` interface using the <<elasticsearch.clients.transport>>.
.ElasticsearchTemplate configuration
====
[source,java]
----
@Configuration
public class TransportClientConfig extends ElasticsearchConfigurationSupport {
@Bean
public Client elasticsearchClient() throws UnknownHostException { <1>
Settings settings = Settings.builder().put("cluster.name", "elasticsearch").build();
TransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(new TransportAddress(InetAddress.getByName("127.0.0.1"), 9300));
return client;
}
@Bean(name = {"elasticsearchOperations", "elasticsearchTemplate"})
public ElasticsearchTemplate elasticsearchTemplate() throws UnknownHostException { <2>
return new ElasticsearchTemplate(elasticsearchClient());
}
}
----
<1> Setting up the <<elasticsearch.clients.transport>>.
Deprecated as of version 4.0.
<2> Creating the `ElasticsearchTemplate` bean, offering both names, _elasticsearchOperations_ and _elasticsearchTemplate_.
====
[[elasticsearch.operations.resttemplate]]
== ElasticsearchRestTemplate

222
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/AbstractElasticsearchRestTransportTemplate.java
View File

@ -1,222 +0,0 @@
/*
* Copyright 2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.elasticsearch.Version;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.search.MultiSearchRequest;
import org.elasticsearch.action.search.MultiSearchResponse;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.index.query.MoreLikeThisQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.search.suggest.SuggestBuilder;
import org.springframework.data.elasticsearch.BulkFailureException;
import org.springframework.data.elasticsearch.backend.elasticsearch7.document.SearchDocumentResponse;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.AbstractElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.IndexedObjectInformation;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.MoreLikeThisQuery;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.util.Assert;
/**
* This class contains methods that are common the implementations derived from {@link AbstractElasticsearchTemplate}
* using either the {@link org.elasticsearch.client.transport.TransportClient} or the
* {@link org.elasticsearch.client.RestHighLevelClient} and that use Elasticsearch specific libraries.
* <p>
* <strong>Note:</strong> Although this class is public, it is not considered to be part of the official Spring Data
* Elasticsearch API and so might change at any time.
*
* @author Peter-Josef Meisch
*/
public abstract class AbstractElasticsearchRestTransportTemplate extends AbstractElasticsearchTemplate {
// region DocumentOperations
/**
* @param bulkResponse
* @return the list of the item id's
*/
protected List<IndexedObjectInformation> checkForBulkOperationFailure(BulkResponse bulkResponse) {
if (bulkResponse.hasFailures()) {
Map<String, String> failedDocuments = new HashMap<>();
for (BulkItemResponse item : bulkResponse.getItems()) {
if (item.isFailed())
failedDocuments.put(item.getId(), item.getFailureMessage());
}
throw new BulkFailureException(
"Bulk operation has failures. Use ElasticsearchException.getFailedDocuments() for detailed messages ["
+ failedDocuments + ']',
failedDocuments);
}
return Stream.of(bulkResponse.getItems()).map(bulkItemResponse -> {
DocWriteResponse response = bulkItemResponse.getResponse();
if (response != null) {
return IndexedObjectInformation.of(response.getId(), response.getSeqNo(), response.getPrimaryTerm(),
response.getVersion());
} else {
return IndexedObjectInformation.of(bulkItemResponse.getId(), null, null, null);
}
}).collect(Collectors.toList());
}
// endregion
// region SearchOperations
protected <T> SearchHits<T> doSearch(MoreLikeThisQuery query, Class<T> clazz, IndexCoordinates index) {
MoreLikeThisQueryBuilder moreLikeThisQueryBuilder = requestFactory.moreLikeThisQueryBuilder(query, index);
return search(
new NativeSearchQueryBuilder().withQuery(moreLikeThisQueryBuilder).withPageable(query.getPageable()).build(),
clazz, index);
}
@Override
public <T> List<SearchHits<T>> multiSearch(List<? extends Query> queries, Class<T> clazz, IndexCoordinates index) {
MultiSearchRequest request = new MultiSearchRequest();
for (Query query : queries) {
request.add(requestFactory.searchRequest(query, clazz, index));
}
MultiSearchResponse.Item[] items = getMultiSearchResult(request);
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<T>(elasticsearchConverter, clazz, index);
SearchDocumentResponseCallback<SearchHits<T>> callback = new ReadSearchDocumentResponseCallback<>(clazz, index);
List<SearchHits<T>> res = new ArrayList<>(queries.size());
int c = 0;
for (Query query : queries) {
res.add(callback.doWith(SearchDocumentResponse.from(items[c++].getResponse(), documentCallback::doWith)));
}
return res;
}
@Override
public List<SearchHits<?>> multiSearch(List<? extends Query> queries, List<Class<?>> classes) {
Assert.notNull(queries, "queries must not be null");
Assert.notNull(classes, "classes must not be null");
Assert.isTrue(queries.size() == classes.size(), "queries and classes must have the same size");
MultiSearchRequest request = new MultiSearchRequest();
Iterator<Class<?>> it = classes.iterator();
for (Query query : queries) {
Class<?> clazz = it.next();
request.add(requestFactory.searchRequest(query, clazz, getIndexCoordinatesFor(clazz)));
}
MultiSearchResponse.Item[] items = getMultiSearchResult(request);
List<SearchHits<?>> res = new ArrayList<>(queries.size());
int c = 0;
Iterator<Class<?>> it1 = classes.iterator();
for (Query query : queries) {
Class entityClass = it1.next();
IndexCoordinates index = getIndexCoordinatesFor(entityClass);
ReadDocumentCallback<?> documentCallback = new ReadDocumentCallback<>(elasticsearchConverter, entityClass, index);
SearchDocumentResponseCallback<SearchHits<?>> callback = new ReadSearchDocumentResponseCallback<>(entityClass,
index);
SearchResponse response = items[c++].getResponse();
res.add(callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith)));
}
return res;
}
@Override
public List<SearchHits<?>> multiSearch(List<? extends Query> queries, List<Class<?>> classes,
IndexCoordinates index) {
Assert.notNull(queries, "queries must not be null");
Assert.notNull(classes, "classes must not be null");
Assert.notNull(index, "index must not be null");
Assert.isTrue(queries.size() == classes.size(), "queries and classes must have the same size");
MultiSearchRequest request = new MultiSearchRequest();
Iterator<Class<?>> it = classes.iterator();
for (Query query : queries) {
request.add(requestFactory.searchRequest(query, it.next(), index));
}
MultiSearchResponse.Item[] items = getMultiSearchResult(request);
List<SearchHits<?>> res = new ArrayList<>(queries.size());
int c = 0;
Iterator<Class<?>> it1 = classes.iterator();
for (Query query : queries) {
Class entityClass = it1.next();
ReadDocumentCallback<?> documentCallback = new ReadDocumentCallback<>(elasticsearchConverter, entityClass, index);
SearchDocumentResponseCallback<SearchHits<?>> callback = new ReadSearchDocumentResponseCallback<>(entityClass,
index);
SearchResponse response = items[c++].getResponse();
res.add(callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith)));
}
return res;
}
abstract protected MultiSearchResponse.Item[] getMultiSearchResult(MultiSearchRequest request);
// endregion
// region helper
@Override
public Query matchAllQuery() {
return new NativeSearchQueryBuilder().withQuery(QueryBuilders.matchAllQuery()).build();
}
@Override
public Query idsQuery(List<String> ids) {
Assert.notNull(ids, "ids must not be null");
return new NativeSearchQueryBuilder().withQuery(QueryBuilders.idsQuery().addIds(ids.toArray(new String[] {})))
.build();
}
@Override
protected String getVendor() {
return "Elasticsearch";
}
@Override
protected String getRuntimeLibraryVersion() {
return Version.CURRENT.toString();
}
@Override
@Deprecated
public SearchResponse suggest(SuggestBuilder suggestion, Class<?> clazz) {
return suggest(suggestion, getIndexCoordinatesFor(clazz));
}
// endregion
}

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/CriteriaFilterProcessor.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import static org.springframework.data.elasticsearch.core.query.Criteria.*;

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/CriteriaQueryProcessor.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import static org.elasticsearch.index.query.Operator.*;
import static org.elasticsearch.index.query.QueryBuilders.*;

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/ElasticsearchAggregation.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import org.elasticsearch.search.aggregations.Aggregation;
import org.springframework.data.elasticsearch.core.AggregationContainer;

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/ElasticsearchAggregations.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import org.elasticsearch.search.aggregations.Aggregations;
import org.springframework.data.elasticsearch.core.AggregationsContainer;

191
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/ElasticsearchRestTemplate.java
View File

@ -16,10 +16,19 @@
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import org.elasticsearch.Version;
import org.elasticsearch.action.DocWriteResponse;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetResponse;
@ -38,6 +47,8 @@ import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.client.RequestOptions;
import org.elasticsearch.client.RestHighLevelClient;
import org.elasticsearch.core.TimeValue;
import org.elasticsearch.index.query.MoreLikeThisQueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.index.reindex.UpdateByQueryRequest;
@ -45,11 +56,11 @@ import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.elasticsearch.search.suggest.SuggestBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.elasticsearch.BulkFailureException;
import org.springframework.data.elasticsearch.backend.elasticsearch7.cluster.ElasticsearchClusterOperations;
import org.springframework.data.elasticsearch.backend.elasticsearch7.document.DocumentAdapters;
import org.springframework.data.elasticsearch.backend.elasticsearch7.document.SearchDocumentResponse;
import org.springframework.data.elasticsearch.clients.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.AbstractElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.IndexedObjectInformation;
@ -63,6 +74,7 @@ import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.BulkOptions;
import org.springframework.data.elasticsearch.core.query.ByQueryResponse;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.MoreLikeThisQuery;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.core.query.UpdateQuery;
import org.springframework.data.elasticsearch.core.query.UpdateResponse;
@ -102,7 +114,7 @@ import org.springframework.util.Assert;
* @author Massimiliano Poggi
* @author Farid Faoudi
*/
public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTransportTemplate {
public class ElasticsearchRestTemplate extends AbstractElasticsearchTemplate {
private static final Logger LOGGER = LoggerFactory.getLogger(ElasticsearchRestTemplate.class);
@ -115,24 +127,21 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTranspor
Assert.notNull(client, "Client must not be null!");
this.client = client;
initialize(createElasticsearchConverter());
}
public ElasticsearchRestTemplate(RestHighLevelClient client, ElasticsearchConverter elasticsearchConverter) {
super(elasticsearchConverter);
Assert.notNull(client, "Client must not be null!");
this.client = client;
initialize(elasticsearchConverter);
}
@Override
protected AbstractElasticsearchTemplate doCopy() {
return new ElasticsearchRestTemplate(client, elasticsearchConverter);
}
// endregion
// region IndexOperations
@ -284,11 +293,11 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTranspor
}
/**
* Pre process the write request before it is sent to the server, eg. by setting the
* Preprocess the write request before it is sent to the server, e.g. by setting the
* {@link WriteRequest#setRefreshPolicy(String) refresh policy} if applicable.
*
* @param request must not be {@literal null}.
* @param <R>
* @param <R> the request type
* @return the processed {@link WriteRequest}.
*/
protected <R extends WriteRequest<R>> R prepareWriteRequest(R request) {
@ -300,6 +309,39 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTranspor
return request.setRefreshPolicy(RequestFactory.toElasticsearchRefreshPolicy(refreshPolicy));
}
/**
* extract the list of {@link IndexedObjectInformation} from a {@link BulkResponse}.
*
* @param bulkResponse the response to evaluate
* @return the list of the {@link IndexedObjectInformation}s
*/
protected List<IndexedObjectInformation> checkForBulkOperationFailure(BulkResponse bulkResponse) {
if (bulkResponse.hasFailures()) {
Map<String, String> failedDocuments = new HashMap<>();
for (BulkItemResponse item : bulkResponse.getItems()) {
if (item.isFailed())
failedDocuments.put(item.getId(), item.getFailureMessage());
}
throw new BulkFailureException(
"Bulk operation has failures. Use ElasticsearchException.getFailedDocuments() for detailed messages ["
+ failedDocuments + ']',
failedDocuments);
}
return Stream.of(bulkResponse.getItems()).map(bulkItemResponse -> {
DocWriteResponse response = bulkItemResponse.getResponse();
if (response != null) {
return IndexedObjectInformation.of(response.getId(), response.getSeqNo(), response.getPrimaryTerm(),
response.getVersion());
} else {
return IndexedObjectInformation.of(bulkItemResponse.getId(), null, null, null);
}
}).collect(Collectors.toList());
}
// endregion
// region SearchOperations
@ -325,12 +367,19 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTranspor
SearchRequest searchRequest = requestFactory.searchRequest(query, clazz, index);
SearchResponse response = execute(client -> client.search(searchRequest, RequestOptions.DEFAULT));
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<T>(elasticsearchConverter, clazz, index);
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<>(elasticsearchConverter, clazz, index);
SearchDocumentResponseCallback<SearchHits<T>> callback = new ReadSearchDocumentResponseCallback<>(clazz, index);
return callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith));
}
protected <T> SearchHits<T> doSearch(MoreLikeThisQuery query, Class<T> clazz, IndexCoordinates index) {
MoreLikeThisQueryBuilder moreLikeThisQueryBuilder = requestFactory.moreLikeThisQueryBuilder(query, index);
return search(
new NativeSearchQueryBuilder().withQuery(moreLikeThisQueryBuilder).withPageable(query.getPageable()).build(),
clazz, index);
}
@Override
public <T> SearchScrollHits<T> searchScrollStart(long scrollTimeInMillis, Query query, Class<T> clazz,
IndexCoordinates index) {
@ -342,7 +391,7 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTranspor
SearchResponse response = execute(client -> client.search(searchRequest, RequestOptions.DEFAULT));
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<T>(elasticsearchConverter, clazz, index);
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<>(elasticsearchConverter, clazz, index);
SearchDocumentResponseCallback<SearchScrollHits<T>> callback = new ReadSearchScrollDocumentResponseCallback<>(clazz,
index);
return callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith));
@ -357,7 +406,7 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTranspor
SearchResponse response = execute(client -> client.scroll(request, RequestOptions.DEFAULT));
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<T>(elasticsearchConverter, clazz, index);
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<>(elasticsearchConverter, clazz, index);
SearchDocumentResponseCallback<SearchScrollHits<T>> callback = new ReadSearchScrollDocumentResponseCallback<>(clazz,
index);
return callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith));
@ -381,8 +430,91 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTranspor
}
@Override
public <T> List<SearchHits<T>> multiSearch(List<? extends Query> queries, Class<T> clazz, IndexCoordinates index) {
MultiSearchRequest request = new MultiSearchRequest();
for (Query query : queries) {
request.add(requestFactory.searchRequest(query, clazz, index));
}
MultiSearchResponse.Item[] items = getMultiSearchResult(request);
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<>(elasticsearchConverter, clazz, index);
SearchDocumentResponseCallback<SearchHits<T>> callback = new ReadSearchDocumentResponseCallback<>(clazz, index);
List<SearchHits<T>> res = new ArrayList<>(queries.size());
for (int i = 0; i < queries.size(); i++) {
res.add(callback.doWith(SearchDocumentResponse.from(items[i].getResponse(), documentCallback::doWith)));
}
return res;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public List<SearchHits<?>> multiSearch(List<? extends Query> queries, List<Class<?>> classes) {
Assert.notNull(queries, "queries must not be null");
Assert.notNull(classes, "classes must not be null");
Assert.isTrue(queries.size() == classes.size(), "queries and classes must have the same size");
MultiSearchRequest request = new MultiSearchRequest();
Iterator<Class<?>> it = classes.iterator();
for (Query query : queries) {
Class<?> clazz = it.next();
request.add(requestFactory.searchRequest(query, clazz, getIndexCoordinatesFor(clazz)));
}
MultiSearchResponse.Item[] items = getMultiSearchResult(request);
List<SearchHits<?>> res = new ArrayList<>(queries.size());
Iterator<Class<?>> it1 = classes.iterator();
for (int i = 0; i < queries.size(); i++) {
Class entityClass = it1.next();
IndexCoordinates index = getIndexCoordinatesFor(entityClass);
ReadDocumentCallback<?> documentCallback = new ReadDocumentCallback<>(elasticsearchConverter, entityClass, index);
SearchDocumentResponseCallback<SearchHits<?>> callback = new ReadSearchDocumentResponseCallback<>(entityClass,
index);
SearchResponse response = items[i].getResponse();
res.add(callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith)));
}
return res;
}
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
public List<SearchHits<?>> multiSearch(List<? extends Query> queries, List<Class<?>> classes,
IndexCoordinates index) {
Assert.notNull(queries, "queries must not be null");
Assert.notNull(classes, "classes must not be null");
Assert.notNull(index, "index must not be null");
Assert.isTrue(queries.size() == classes.size(), "queries and classes must have the same size");
MultiSearchRequest request = new MultiSearchRequest();
Iterator<Class<?>> it = classes.iterator();
for (Query query : queries) {
request.add(requestFactory.searchRequest(query, it.next(), index));
}
MultiSearchResponse.Item[] items = getMultiSearchResult(request);
List<SearchHits<?>> res = new ArrayList<>(queries.size());
Iterator<Class<?>> it1 = classes.iterator();
for (int i = 0; i < queries.size(); i++) {
Class entityClass = it1.next();
ReadDocumentCallback<?> documentCallback = new ReadDocumentCallback<>(elasticsearchConverter, entityClass, index);
SearchDocumentResponseCallback<SearchHits<?>> callback = new ReadSearchDocumentResponseCallback<>(entityClass,
index);
SearchResponse response = items[i].getResponse();
res.add(callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith)));
}
return res;
}
protected MultiSearchResponse.Item[] getMultiSearchResult(MultiSearchRequest request) {
MultiSearchResponse response = execute(client -> client.multiSearch(request, RequestOptions.DEFAULT));
MultiSearchResponse response = execute(client -> client.msearch(request, RequestOptions.DEFAULT));
MultiSearchResponse.Item[] items = response.getResponses();
Assert.isTrue(items.length == request.requests().size(), "Response should has same length with queries");
return items;
@ -448,5 +580,36 @@ public class ElasticsearchRestTemplate extends AbstractElasticsearchRestTranspor
} catch (Exception ignored) {}
return null;
}
@Override
public Query matchAllQuery() {
return new NativeSearchQueryBuilder().withQuery(QueryBuilders.matchAllQuery()).build();
}
@Override
public Query idsQuery(List<String> ids) {
Assert.notNull(ids, "ids must not be null");
return new NativeSearchQueryBuilder().withQuery(QueryBuilders.idsQuery().addIds(ids.toArray(new String[] {})))
.build();
}
@Override
protected String getVendor() {
return "Elasticsearch";
}
@Override
protected String getRuntimeLibraryVersion() {
return Version.CURRENT.toString();
}
@Override
@Deprecated
public SearchResponse suggest(SuggestBuilder suggestion, Class<?> clazz) {
return suggest(suggestion, getIndexCoordinatesFor(clazz));
}
// endregion
}

482
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/ElasticsearchTemplate.java
View File

@ -1,482 +0,0 @@
/*
* Copyright 2013-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.Collectors;
import org.elasticsearch.action.ActionFuture;
import org.elasticsearch.action.admin.cluster.node.info.NodesInfoAction;
import org.elasticsearch.action.admin.cluster.node.info.NodesInfoRequestBuilder;
import org.elasticsearch.action.admin.cluster.node.info.NodesInfoResponse;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.delete.DeleteRequestBuilder;
import org.elasticsearch.action.get.GetRequestBuilder;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.get.MultiGetRequestBuilder;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.MultiSearchRequest;
import org.elasticsearch.action.search.MultiSearchResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.support.WriteRequestBuilder;
import org.elasticsearch.action.update.UpdateRequestBuilder;
import org.elasticsearch.client.Client;
import org.elasticsearch.core.TimeValue;
import org.elasticsearch.index.reindex.BulkByScrollResponse;
import org.elasticsearch.index.reindex.UpdateByQueryRequestBuilder;
import org.elasticsearch.search.suggest.SuggestBuilder;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.elasticsearch.backend.elasticsearch7.cluster.ElasticsearchClusterOperations;
import org.springframework.data.elasticsearch.backend.elasticsearch7.document.DocumentAdapters;
import org.springframework.data.elasticsearch.backend.elasticsearch7.document.SearchDocumentResponse;
import org.springframework.data.elasticsearch.clients.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.AbstractElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.IndexedObjectInformation;
import org.springframework.data.elasticsearch.core.MultiGetItem;
import org.springframework.data.elasticsearch.core.RefreshPolicy;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.SearchScrollHits;
import org.springframework.data.elasticsearch.core.cluster.ClusterOperations;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.BulkOptions;
import org.springframework.data.elasticsearch.core.query.ByQueryResponse;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.core.query.UpdateQuery;
import org.springframework.data.elasticsearch.core.query.UpdateResponse;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* ElasticsearchTemplate
*
* @author Rizwan Idrees
* @author Mohsin Husen
* @author Artur Konczak
* @author Kevin Leturc
* @author Mason Chan
* @author Young Gu
* @author Oliver Gierke
* @author Mark Janssen
* @author Chris White
* @author Mark Paluch
* @author Ilkang Na
* @author Alen Turkovic
* @author Sascha Woo
* @author Ted Liang
* @author Jean-Baptiste Nizet
* @author Zetang Zeng
* @author Ivan Greene
* @author Christoph Strobl
* @author Dmitriy Yakovlev
* @author Peter-Josef Meisch
* @author Martin Choraine
* @author Farid Azaza
* @author Gyula Attila Csorogi
* @author Roman Puchkovskiy
* @author Farid Faoudi
* @deprecated as of 4.0
*/
@Deprecated
public class ElasticsearchTemplate extends AbstractElasticsearchRestTransportTemplate {
private static final Logger QUERY_LOGGER = LoggerFactory
.getLogger("org.springframework.data.elasticsearch.core.QUERY");
private static final Logger LOGGER = LoggerFactory.getLogger(ElasticsearchTemplate.class);
private Client client;
@Nullable private String searchTimeout;
private final ElasticsearchExceptionTranslator exceptionTranslator = new ElasticsearchExceptionTranslator();
// region Initialization
public ElasticsearchTemplate(Client client) {
this.client = client;
initialize(client, createElasticsearchConverter());
}
public ElasticsearchTemplate(Client client, ElasticsearchConverter elasticsearchConverter) {
this.client = client;
initialize(client, elasticsearchConverter);
}
private void initialize(Client client, ElasticsearchConverter elasticsearchConverter) {
Assert.notNull(client, "Client must not be null!");
this.client = client;
initialize(elasticsearchConverter);
}
@Override
protected AbstractElasticsearchTemplate doCopy() {
ElasticsearchTemplate elasticsearchTemplate = new ElasticsearchTemplate(client, elasticsearchConverter);
elasticsearchTemplate.setSearchTimeout(searchTimeout);
return elasticsearchTemplate;
}
// endregion
// region IndexOperations
@Override
public IndexOperations indexOps(Class<?> clazz) {
Assert.notNull(clazz, "clazz must not be null");
return new TransportIndexTemplate(client, elasticsearchConverter, clazz);
}
@Override
public IndexOperations indexOps(IndexCoordinates index) {
Assert.notNull(index, "index must not be null");
return new TransportIndexTemplate(client, elasticsearchConverter, index);
}
// endregion
// region ClusterOperations
@Override
public ClusterOperations cluster() {
return ElasticsearchClusterOperations.forTemplate(this);
}
// endregion
// region getter/setter
@Nullable
public String getSearchTimeout() {
return searchTimeout;
}
public void setSearchTimeout(String searchTimeout) {
this.searchTimeout = searchTimeout;
}
// endregion
// region DocumentOperations
public String doIndex(IndexQuery query, IndexCoordinates index) {
IndexRequestBuilder indexRequestBuilder = requestFactory.indexRequestBuilder(client, query, index);
indexRequestBuilder = prepareWriteRequestBuilder(indexRequestBuilder);
ActionFuture<IndexResponse> future = indexRequestBuilder.execute();
IndexResponse response;
try {
response = future.actionGet();
} catch (RuntimeException e) {
throw translateException(e);
}
String documentId = response.getId();
Object queryObject = query.getObject();
if (queryObject != null) {
query.setObject(updateIndexedObject(queryObject, IndexedObjectInformation.of(documentId, response.getSeqNo(),
response.getPrimaryTerm(), response.getVersion())));
}
return documentId;
}
@Override
@Nullable
public <T> T get(String id, Class<T> clazz, IndexCoordinates index) {
GetRequestBuilder getRequestBuilder = requestFactory.getRequestBuilder(client, id, routingResolver.getRouting(),
index);
GetResponse response = getRequestBuilder.execute().actionGet();
DocumentCallback<T> callback = new ReadDocumentCallback<>(elasticsearchConverter, clazz, index);
return callback.doWith(DocumentAdapters.from(response));
}
@Override
public <T> List<MultiGetItem<T>> multiGet(Query query, Class<T> clazz, IndexCoordinates index) {
Assert.notNull(index, "index must not be null");
MultiGetRequestBuilder builder = requestFactory.multiGetRequestBuilder(client, query, clazz, index);
DocumentCallback<T> callback = new ReadDocumentCallback<>(elasticsearchConverter, clazz, index);
return DocumentAdapters.from(builder.execute().actionGet()).stream() //
.map(multiGetItem -> MultiGetItem.of(multiGetItem.isFailed() ? null : callback.doWith(multiGetItem.getItem()),
multiGetItem.getFailure()))
.collect(Collectors.toList());
}
@Override
protected boolean doExists(String id, IndexCoordinates index) {
GetRequestBuilder getRequestBuilder = requestFactory.getRequestBuilder(client, id, routingResolver.getRouting(),
index);
getRequestBuilder.setFetchSource(false);
return getRequestBuilder.execute().actionGet().isExists();
}
@Override
public void bulkUpdate(List<UpdateQuery> queries, BulkOptions bulkOptions, IndexCoordinates index) {
Assert.notNull(queries, "List of UpdateQuery must not be null");
Assert.notNull(bulkOptions, "BulkOptions must not be null");
doBulkOperation(queries, bulkOptions, index);
}
@Override
protected String doDelete(String id, @Nullable String routing, IndexCoordinates index) {
Assert.notNull(id, "id must not be null");
Assert.notNull(index, "index must not be null");
DeleteRequestBuilder deleteRequestBuilder = prepareWriteRequestBuilder(
requestFactory.deleteRequestBuilder(client, elasticsearchConverter.convertId(id), routing, index));
return deleteRequestBuilder.execute().actionGet().getId();
}
@Override
public ByQueryResponse delete(Query query, Class<?> clazz, IndexCoordinates index) {
return ResponseConverter
.byQueryResponseOf(requestFactory.deleteByQueryRequestBuilder(client, query, clazz, index).get());
}
@Override
public String delete(Object entity, IndexCoordinates index) {
return super.delete(entity, index);
}
@Override
public UpdateResponse update(UpdateQuery query, IndexCoordinates index) {
UpdateRequestBuilder updateRequestBuilder = requestFactory.updateRequestBuilderFor(client, query, index);
if (query.getRefreshPolicy() == null && getRefreshPolicy() != null) {
updateRequestBuilder.setRefreshPolicy(RequestFactory.toElasticsearchRefreshPolicy(getRefreshPolicy()));
}
if (query.getRouting() == null && routingResolver.getRouting() != null) {
updateRequestBuilder.setRouting(routingResolver.getRouting());
}
org.elasticsearch.action.update.UpdateResponse updateResponse = updateRequestBuilder.execute().actionGet();
UpdateResponse.Result result = UpdateResponse.Result.valueOf(updateResponse.getResult().name());
return new UpdateResponse(result);
}
@Override
public ByQueryResponse updateByQuery(UpdateQuery query, IndexCoordinates index) {
Assert.notNull(query, "query must not be null");
Assert.notNull(index, "index must not be null");
final UpdateByQueryRequestBuilder updateByQueryRequestBuilder = requestFactory.updateByQueryRequestBuilder(client,
query, index);
if (query.getRefreshPolicy() == null && getRefreshPolicy() != null) {
updateByQueryRequestBuilder.refresh(getRefreshPolicy() == RefreshPolicy.IMMEDIATE);
}
// UpdateByQueryRequestBuilder has not parameters to set a routing value
final BulkByScrollResponse bulkByScrollResponse = updateByQueryRequestBuilder.execute().actionGet();
return ResponseConverter.byQueryResponseOf(bulkByScrollResponse);
}
public List<IndexedObjectInformation> doBulkOperation(List<?> queries, BulkOptions bulkOptions,
IndexCoordinates index) {
// do it in batches; test code on some machines kills the transport node when the size gets too much
Collection<? extends List<?>> queryLists = partitionBasedOnSize(queries, 2500);
List<IndexedObjectInformation> allIndexedObjectInformations = new ArrayList<>(queries.size());
queryLists.forEach(queryList -> {
BulkRequestBuilder bulkRequestBuilder = requestFactory.bulkRequestBuilder(client, queryList, bulkOptions, index);
bulkRequestBuilder = prepareWriteRequestBuilder(bulkRequestBuilder);
final List<IndexedObjectInformation> indexedObjectInformations = checkForBulkOperationFailure(
bulkRequestBuilder.execute().actionGet());
updateIndexedObjectsWithQueries(queryList, indexedObjectInformations);
allIndexedObjectInformations.addAll(indexedObjectInformations);
});
return allIndexedObjectInformations;
}
/**
* Pre process the write request before it is sent to the server, eg. by setting the
* {@link WriteRequest#setRefreshPolicy(String) refresh policy} if applicable.
*
* @param requestBuilder must not be {@literal null}.
* @param <R>
* @return the processed {@link WriteRequest}.
*/
protected <R extends WriteRequestBuilder<R>> R prepareWriteRequestBuilder(R requestBuilder) {
if (refreshPolicy == null) {
return requestBuilder;
}
return requestBuilder.setRefreshPolicy(RequestFactory.toElasticsearchRefreshPolicy(refreshPolicy));
}
// endregion
// region SearchOperations
@Override
public long count(Query query, @Nullable Class<?> clazz, IndexCoordinates index) {
Assert.notNull(query, "query must not be null");
Assert.notNull(index, "index must not be null");
final Boolean trackTotalHits = query.getTrackTotalHits();
query.setTrackTotalHits(true);
SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, clazz, index);
query.setTrackTotalHits(trackTotalHits);
searchRequestBuilder.setSize(0);
return SearchHitsUtil.getTotalCount(getSearchResponse(searchRequestBuilder).getHits());
}
@Override
public <T> SearchHits<T> search(Query query, Class<T> clazz, IndexCoordinates index) {
SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, clazz, index);
SearchResponse response = getSearchResponse(searchRequestBuilder);
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<T>(elasticsearchConverter, clazz, index);
SearchDocumentResponseCallback<SearchHits<T>> callback = new ReadSearchDocumentResponseCallback<>(clazz, index);
return callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith));
}
@Override
public <T> SearchScrollHits<T> searchScrollStart(long scrollTimeInMillis, Query query, Class<T> clazz,
IndexCoordinates index) {
Assert.notNull(query.getPageable(), "pageable of query must not be null.");
ActionFuture<SearchResponse> action = requestFactory.searchRequestBuilder(client, query, clazz, index) //
.setScroll(TimeValue.timeValueMillis(scrollTimeInMillis)) //
.execute();
SearchResponse response = getSearchResponseWithTimeout(action);
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<T>(elasticsearchConverter, clazz, index);
SearchDocumentResponseCallback<SearchScrollHits<T>> callback = new ReadSearchScrollDocumentResponseCallback<>(clazz,
index);
return callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith));
}
@Override
public <T> SearchScrollHits<T> searchScrollContinue(@Nullable String scrollId, long scrollTimeInMillis,
Class<T> clazz, IndexCoordinates index) {
ActionFuture<SearchResponse> action = client //
.prepareSearchScroll(scrollId) //
.setScroll(TimeValue.timeValueMillis(scrollTimeInMillis)) //
.execute();
SearchResponse response = getSearchResponseWithTimeout(action);
ReadDocumentCallback<T> documentCallback = new ReadDocumentCallback<T>(elasticsearchConverter, clazz, index);
SearchDocumentResponseCallback<SearchScrollHits<T>> callback = new ReadSearchScrollDocumentResponseCallback<>(clazz,
index);
return callback.doWith(SearchDocumentResponse.from(response, documentCallback::doWith));
}
@Override
public void searchScrollClear(List<String> scrollIds) {
try {
client.prepareClearScroll().setScrollIds(scrollIds).execute().actionGet();
} catch (Exception e) {
LOGGER.warn("Could not clear scroll: {}", e.getMessage());
}
}
@Override
public SearchResponse suggest(SuggestBuilder suggestion, IndexCoordinates index) {
SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, suggestion, index);
return searchRequestBuilder.get();
}
@Override
protected MultiSearchResponse.Item[] getMultiSearchResult(MultiSearchRequest request) {
ActionFuture<MultiSearchResponse> future = client.multiSearch(request);
MultiSearchResponse response = future.actionGet();
MultiSearchResponse.Item[] items = response.getResponses();
Assert.isTrue(items.length == request.requests().size(), "Response should have same length with queries");
return items;
}
private SearchResponse getSearchResponse(SearchRequestBuilder requestBuilder) {
if (QUERY_LOGGER.isDebugEnabled()) {
QUERY_LOGGER.debug(requestBuilder.toString());
}
return getSearchResponseWithTimeout(requestBuilder.execute());
}
private SearchResponse getSearchResponseWithTimeout(ActionFuture<SearchResponse> response) {
return searchTimeout == null ? response.actionGet() : response.actionGet(searchTimeout);
}
// endregion
// region helper methods
@Override
protected String getClusterVersion() {
try {
NodesInfoResponse nodesInfoResponse = client.admin().cluster()
.nodesInfo(new NodesInfoRequestBuilder(client, NodesInfoAction.INSTANCE).request()).actionGet();
if (!nodesInfoResponse.getNodes().isEmpty()) {
return nodesInfoResponse.getNodes().get(0).getVersion().toString();
}
} catch (Exception ignored) {}
return null;
}
public Client getClient() {
return client;
}
<T> Collection<List<T>> partitionBasedOnSize(List<T> inputList, int size) {
final AtomicInteger counter = new AtomicInteger(0);
return inputList.stream().collect(Collectors.groupingBy(s -> counter.getAndIncrement() / size)).values();
}
// endregion
/**
* translates an Exception if possible. Exceptions that are no {@link RuntimeException}s are wrapped in a
* RuntimeException
*
* @param exception the Exception to map
* @return the potentially translated RuntimeException.
* @since 4.0
*/
private RuntimeException translateException(Exception exception) {
RuntimeException runtimeException = exception instanceof RuntimeException ? (RuntimeException) exception
: new RuntimeException(exception.getMessage(), exception);
RuntimeException potentiallyTranslatedException = exceptionTranslator
.translateExceptionIfPossible(runtimeException);
return potentiallyTranslatedException != null ? potentiallyTranslatedException : runtimeException;
}
}

3
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/ReactiveElasticsearchTemplate.java
View File

@ -61,9 +61,6 @@ import org.springframework.data.elasticsearch.backend.elasticsearch7.cluster.Def
import org.springframework.data.elasticsearch.backend.elasticsearch7.document.DocumentAdapters;
import org.springframework.data.elasticsearch.backend.elasticsearch7.document.SearchDocumentResponse;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ElasticsearchAggregation;
import org.springframework.data.elasticsearch.clients.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.*;
import org.springframework.data.elasticsearch.core.EntityOperations.AdaptibleEntity;
import org.springframework.data.elasticsearch.core.cluster.ReactiveClusterOperations;

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/ReactiveIndexTemplate.java
View File

@ -42,8 +42,6 @@ import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.data.elasticsearch.NoSuchIndexException;
import org.springframework.data.elasticsearch.annotations.Mapping;
import org.springframework.data.elasticsearch.clients.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.IndexInformation;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ReactiveIndexOperations;

582
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/RequestFactory.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import static org.elasticsearch.index.query.QueryBuilders.*;
import static org.springframework.util.CollectionUtils.*;
@ -33,33 +33,23 @@ import java.util.stream.Collectors;
import org.elasticsearch.action.DocWriteRequest;
import org.elasticsearch.action.admin.indices.alias.Alias;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequestBuilder;
import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest;
import org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest;
import org.elasticsearch.action.bulk.BulkRequest;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.delete.DeleteRequest;
import org.elasticsearch.action.delete.DeleteRequestBuilder;
import org.elasticsearch.action.get.GetRequest;
import org.elasticsearch.action.get.GetRequestBuilder;
import org.elasticsearch.action.get.MultiGetRequest;
import org.elasticsearch.action.get.MultiGetRequestBuilder;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.action.support.ActiveShardCount;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.update.UpdateRequest;
import org.elasticsearch.action.update.UpdateRequestBuilder;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.Requests;
import org.elasticsearch.client.indices.CreateIndexRequest;
import org.elasticsearch.client.indices.GetIndexRequest;
@ -75,12 +65,8 @@ import org.elasticsearch.index.VersionType;
import org.elasticsearch.index.query.MoreLikeThisQueryBuilder;
import org.elasticsearch.index.query.QueryBuilder;
import org.elasticsearch.index.query.QueryBuilders;
import org.elasticsearch.index.reindex.DeleteByQueryAction;
import org.elasticsearch.index.reindex.DeleteByQueryRequest;
import org.elasticsearch.index.reindex.DeleteByQueryRequestBuilder;
import org.elasticsearch.index.reindex.UpdateByQueryAction;
import org.elasticsearch.index.reindex.UpdateByQueryRequest;
import org.elasticsearch.index.reindex.UpdateByQueryRequestBuilder;
import org.elasticsearch.script.Script;
import org.elasticsearch.search.builder.SearchSourceBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
@ -221,12 +207,6 @@ public class RequestFactory {
return request;
}
public IndicesAliasesRequestBuilder indicesAliasesRequestBuilder(Client client, AliasActions aliasActions) {
IndicesAliasesRequestBuilder requestBuilder = client.admin().indices().prepareAliases();
indicesAliasesRequest(aliasActions).getAliasActions().forEach(requestBuilder::addAliasAction);
return requestBuilder;
}
// endregion
// region bulk
@ -264,42 +244,6 @@ public class RequestFactory {
return bulkRequest;
}
public BulkRequestBuilder bulkRequestBuilder(Client client, List<?> queries, BulkOptions bulkOptions,
IndexCoordinates index) {
BulkRequestBuilder bulkRequestBuilder = client.prepareBulk();
if (bulkOptions.getTimeout() != null) {
bulkRequestBuilder.setTimeout(TimeValue.timeValueMillis(bulkOptions.getTimeout().toMillis()));
}
if (bulkOptions.getRefreshPolicy() != null) {
bulkRequestBuilder.setRefreshPolicy(toElasticsearchRefreshPolicy(bulkOptions.getRefreshPolicy()));
}
if (bulkOptions.getWaitForActiveShards() != null) {
bulkRequestBuilder.setWaitForActiveShards(ActiveShardCount.from(bulkOptions.getWaitForActiveShards().getValue()));
}
if (bulkOptions.getPipeline() != null) {
bulkRequestBuilder.pipeline(bulkOptions.getPipeline());
}
if (bulkOptions.getRoutingId() != null) {
bulkRequestBuilder.routing(bulkOptions.getRoutingId());
}
queries.forEach(query -> {
if (query instanceof IndexQuery) {
bulkRequestBuilder.add(indexRequestBuilder(client, (IndexQuery) query, index));
} else if (query instanceof UpdateQuery) {
bulkRequestBuilder.add(updateRequestBuilderFor(client, (UpdateQuery) query, index));
}
});
return bulkRequestBuilder;
}
// endregion
// region index management
@ -323,26 +267,6 @@ public class RequestFactory {
return request;
}
public CreateIndexRequestBuilder createIndexRequestBuilder(Client client, IndexCoordinates index,
Map<String, Object> settings, @Nullable Document mapping) {
Assert.notNull(index, "index must not be null");
Assert.notNull(settings, "settings must not be null");
String indexName = index.getIndexName();
CreateIndexRequestBuilder createIndexRequestBuilder = client.admin().indices().prepareCreate(indexName);
if (!settings.isEmpty()) {
createIndexRequestBuilder.setSettings(settings);
}
if (mapping != null && !mapping.isEmpty()) {
createIndexRequestBuilder.addMapping(IndexCoordinates.TYPE, mapping);
}
return createIndexRequestBuilder;
}
public GetIndexRequest getIndexRequest(IndexCoordinates index) {
return new GetIndexRequest(index.getIndexNames());
}
@ -378,15 +302,6 @@ public class RequestFactory {
return request;
}
public PutMappingRequestBuilder putMappingRequestBuilder(Client client, IndexCoordinates index, Document mapping) {
String[] indexNames = index.getIndexNames();
PutMappingRequestBuilder requestBuilder = client.admin().indices().preparePutMapping(indexNames)
.setType(IndexCoordinates.TYPE);
requestBuilder.setSource(mapping);
return requestBuilder;
}
public GetSettingsRequest getSettingsRequest(String indexName, boolean includeDefaults) {
return new GetSettingsRequest().indices(indexName).includeDefaults(includeDefaults);
}
@ -397,13 +312,6 @@ public class RequestFactory {
return new GetMappingsRequest().indices(indexNames);
}
public org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest getMappingsRequest(
@SuppressWarnings("unused") Client client, IndexCoordinates index) {
String[] indexNames = index.getIndexNames();
return new org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest().indices(indexNames);
}
public PutIndexTemplateRequest putIndexTemplateRequest(PutTemplateRequest putTemplateRequest) {
PutIndexTemplateRequest request = new PutIndexTemplateRequest(putTemplateRequest.getName())
@ -472,87 +380,10 @@ public class RequestFactory {
return request;
}
/**
* The version for the transport client needs a different PutIndexTemplateRequest class
*/
public org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest putIndexTemplateRequest(
@SuppressWarnings("unused") Client client, PutTemplateRequest putTemplateRequest) {
org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest request = new org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest(
putTemplateRequest.getName()).patterns(Arrays.asList(putTemplateRequest.getIndexPatterns()));
if (putTemplateRequest.getSettings() != null) {
request.settings(putTemplateRequest.getSettings());
}
if (putTemplateRequest.getMappings() != null) {
request.mapping("_doc", putTemplateRequest.getMappings());
}
request.order(putTemplateRequest.getOrder()).version(putTemplateRequest.getVersion());
AliasActions aliasActions = putTemplateRequest.getAliasActions();
if (aliasActions != null) {
aliasActions.getActions().forEach(aliasAction -> {
AliasActionParameters parameters = aliasAction.getParameters();
String[] parametersAliases = parameters.getAliases();
if (parametersAliases != null) {
for (String aliasName : parametersAliases) {
Alias alias = new Alias(aliasName);
if (parameters.getRouting() != null) {
alias.routing(parameters.getRouting());
}
if (parameters.getIndexRouting() != null) {
alias.indexRouting(parameters.getIndexRouting());
}
if (parameters.getSearchRouting() != null) {
alias.searchRouting(parameters.getSearchRouting());
}
if (parameters.getHidden() != null) {
alias.isHidden(parameters.getHidden());
}
if (parameters.getWriteIndex() != null) {
alias.writeIndex(parameters.getWriteIndex());
}
Query filterQuery = parameters.getFilterQuery();
if (filterQuery != null) {
elasticsearchConverter.updateQuery(filterQuery, parameters.getFilterQueryClass());
QueryBuilder queryBuilder = getFilter(filterQuery);
if (queryBuilder == null) {
queryBuilder = getQuery(filterQuery);
}
alias.filter(queryBuilder);
}
request.alias(alias);
}
}
});
}
return request;
}
public GetIndexTemplatesRequest getIndexTemplatesRequest(GetTemplateRequest getTemplateRequest) {
return new GetIndexTemplatesRequest(getTemplateRequest.getTemplateName());
}
public org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesRequest getIndexTemplatesRequest(
Client client, GetTemplateRequest getTemplateRequest) {
return new org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesRequest(
getTemplateRequest.getTemplateName());
}
public IndexTemplatesExistRequest indexTemplatesExistsRequest(ExistsTemplateRequest existsTemplateRequest) {
return new IndexTemplatesExistRequest(existsTemplateRequest.getTemplateName());
}
@ -561,11 +392,6 @@ public class RequestFactory {
return new DeleteIndexTemplateRequest(deleteTemplateRequest.getTemplateName());
}
public org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest deleteIndexTemplateRequest(
Client client, DeleteTemplateRequest deleteTemplateRequest) {
return new org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest(
deleteTemplateRequest.getTemplateName());
}
// endregion
// region delete
@ -604,47 +430,6 @@ public class RequestFactory {
return deleteRequest;
}
public DeleteRequestBuilder deleteRequestBuilder(Client client, String id, @Nullable String routing,
IndexCoordinates index) {
String indexName = index.getIndexName();
DeleteRequestBuilder deleteRequestBuilder = client.prepareDelete();
deleteRequestBuilder.setIndex(indexName);
deleteRequestBuilder.setId(id);
if (routing != null) {
deleteRequestBuilder.setRouting(routing);
}
return deleteRequestBuilder;
}
public DeleteByQueryRequestBuilder deleteByQueryRequestBuilder(Client client, Query query, Class<?> clazz,
IndexCoordinates index) {
SearchRequest searchRequest = searchRequest(query, clazz, index);
DeleteByQueryRequestBuilder requestBuilder = new DeleteByQueryRequestBuilder(client, DeleteByQueryAction.INSTANCE) //
.source(index.getIndexNames()) //
.filter(searchRequest.source().query()) //
.abortOnVersionConflict(false) //
.refresh(true);
SearchRequestBuilder source = requestBuilder.source();
if (query.isLimiting()) {
// noinspection ConstantConditions
source.setSize(query.getMaxResults());
}
if (query.hasScrollTime()) {
// noinspection ConstantConditions
source.setScroll(TimeValue.timeValueMillis(query.getScrollTime().toMillis()));
}
if (query.getRoute() != null) {
source.setRouting(query.getRoute());
}
return requestBuilder;
}
// endregion
// region get
@ -654,13 +439,6 @@ public class RequestFactory {
return getRequest;
}
public GetRequestBuilder getRequestBuilder(Client client, String id, @Nullable String routing,
IndexCoordinates index) {
GetRequestBuilder getRequestBuilder = client.prepareGet(index.getIndexName(), null, id);
getRequestBuilder.setRouting(routing);
return getRequestBuilder;
}
public MultiGetRequest multiGetRequest(Query query, Class<?> clazz, IndexCoordinates index) {
MultiGetRequest multiGetRequest = new MultiGetRequest();
@ -668,14 +446,6 @@ public class RequestFactory {
return multiGetRequest;
}
public MultiGetRequestBuilder multiGetRequestBuilder(Client client, Query searchQuery, Class<?> clazz,
IndexCoordinates index) {
MultiGetRequestBuilder multiGetRequestBuilder = client.prepareMultiGet();
getMultiRequestItems(searchQuery, clazz, index).forEach(multiGetRequestBuilder::add);
return multiGetRequestBuilder;
}
private List<MultiGetRequest.Item> getMultiRequestItems(Query searchQuery, Class<?> clazz, IndexCoordinates index) {
elasticsearchConverter.updateQuery(searchQuery, clazz);
@ -762,52 +532,6 @@ public class RequestFactory {
return indexRequest;
}
public IndexRequestBuilder indexRequestBuilder(Client client, IndexQuery query, IndexCoordinates index) {
String indexName = index.getIndexName();
String type = IndexCoordinates.TYPE;
IndexRequestBuilder indexRequestBuilder;
Object queryObject = query.getObject();
if (queryObject != null) {
String id = StringUtils.isEmpty(query.getId()) ? getPersistentEntityId(queryObject) : query.getId();
// If we have a query id and a document id, do not ask ES to generate one.
if (id != null) {
indexRequestBuilder = client.prepareIndex(indexName, type, id);
} else {
indexRequestBuilder = client.prepareIndex(indexName, type);
}
indexRequestBuilder.setSource(elasticsearchConverter.mapObject(queryObject).toJson(),
Requests.INDEX_CONTENT_TYPE);
} else if (query.getSource() != null) {
indexRequestBuilder = client.prepareIndex(indexName, type, query.getId()).setSource(query.getSource(),
Requests.INDEX_CONTENT_TYPE);
} else {
throw new InvalidDataAccessApiUsageException(
"object or source is null, failed to index the document [id: " + query.getId() + ']');
}
if (query.getVersion() != null) {
indexRequestBuilder.setVersion(query.getVersion());
VersionType versionType = retrieveVersionTypeFromPersistentEntity(
queryObject != null ? queryObject.getClass() : null);
indexRequestBuilder.setVersionType(versionType);
}
if (query.getSeqNo() != null) {
indexRequestBuilder.setIfSeqNo(query.getSeqNo());
}
if (query.getPrimaryTerm() != null) {
indexRequestBuilder.setIfPrimaryTerm(query.getPrimaryTerm());
}
if (query.getRouting() != null) {
indexRequestBuilder.setRouting(query.getRouting());
}
return indexRequestBuilder;
}
// endregion
// region search
@ -897,11 +621,6 @@ public class RequestFactory {
return searchRequest;
}
public SearchRequestBuilder searchRequestBuilder(Client client, SuggestBuilder suggestion, IndexCoordinates index) {
String[] indexNames = index.getIndexNames();
return client.prepareSearch(indexNames).suggest(suggestion);
}
public SearchRequest searchRequest(Query query, @Nullable Class<?> clazz, IndexCoordinates index) {
elasticsearchConverter.updateQuery(query, clazz);
@ -919,23 +638,6 @@ public class RequestFactory {
}
public SearchRequestBuilder searchRequestBuilder(Client client, Query query, @Nullable Class<?> clazz,
IndexCoordinates index) {
elasticsearchConverter.updateQuery(query, clazz);
SearchRequestBuilder searchRequestBuilder = prepareSearchRequestBuilder(query, client, clazz, index);
QueryBuilder elasticsearchQuery = getQuery(query);
QueryBuilder elasticsearchFilter = getFilter(query);
searchRequestBuilder.setQuery(elasticsearchQuery);
if (elasticsearchFilter != null) {
searchRequestBuilder.setPostFilter(elasticsearchFilter);
}
return searchRequestBuilder;
}
private SearchRequest prepareSearchRequest(Query query, @Nullable Class<?> clazz, IndexCoordinates indexCoordinates) {
String[] indexNames = indexCoordinates.getIndexNames();
@ -1040,114 +742,9 @@ public class RequestFactory {
}
request.source(sourceBuilder);
return request;
}
private SearchRequestBuilder prepareSearchRequestBuilder(Query query, Client client, @Nullable Class<?> clazz,
IndexCoordinates index) {
String[] indexNames = index.getIndexNames();
Assert.notNull(indexNames, "No index defined for Query");
Assert.notEmpty(indexNames, "No index defined for Query");
SearchRequestBuilder searchRequestBuilder = client.prepareSearch(indexNames) //
.setSearchType(SearchType.fromString(query.getSearchType().name().toLowerCase())) //
.setVersion(true) //
.setTrackScores(query.getTrackScores());
if (hasSeqNoPrimaryTermProperty(clazz)) {
searchRequestBuilder.seqNoAndPrimaryTerm(true);
}
if (query.getPageable().isPaged()) {
searchRequestBuilder.setFrom((int) query.getPageable().getOffset());
searchRequestBuilder.setSize(query.getPageable().getPageSize());
} else {
searchRequestBuilder.setFrom(0);
searchRequestBuilder.setSize(INDEX_MAX_RESULT_WINDOW);
}
if (query.getSourceFilter() != null) {
SourceFilter sourceFilter = query.getSourceFilter();
searchRequestBuilder.setFetchSource(sourceFilter.getIncludes(), sourceFilter.getExcludes());
}
if (!query.getFields().isEmpty()) {
query.getFields().forEach(searchRequestBuilder::addFetchField);
}
if (query.getIndicesOptions() != null) {
searchRequestBuilder.setIndicesOptions(toElasticsearchIndicesOptions(query.getIndicesOptions()));
}
if (query.isLimiting()) {
// noinspection ConstantConditions
searchRequestBuilder.setSize(query.getMaxResults());
}
if (query.getMinScore() > 0) {
searchRequestBuilder.setMinScore(query.getMinScore());
}
if (query.getPreference() != null) {
searchRequestBuilder.setPreference(query.getPreference());
}
prepareSort(query, searchRequestBuilder, getPersistentEntity(clazz));
HighlightBuilder highlightBuilder = highlightBuilder(query);
if (highlightBuilder != null) {
searchRequestBuilder.highlighter(highlightBuilder);
}
if (query instanceof NativeSearchQuery) {
prepareNativeSearch(searchRequestBuilder, (NativeSearchQuery) query);
}
if (query.getTrackTotalHits() != null) {
searchRequestBuilder.setTrackTotalHits(query.getTrackTotalHits());
} else if (query.getTrackTotalHitsUpTo() != null) {
searchRequestBuilder.setTrackTotalHitsUpTo(query.getTrackTotalHitsUpTo());
}
if (StringUtils.hasLength(query.getRoute())) {
searchRequestBuilder.setRouting(query.getRoute());
}
Duration timeout = query.getTimeout();
if (timeout != null) {
searchRequestBuilder.setTimeout(new TimeValue(timeout.toMillis()));
}
searchRequestBuilder.setExplain(query.getExplain());
if (query.getSearchAfter() != null) {
searchRequestBuilder.searchAfter(query.getSearchAfter().toArray());
}
query.getRescorerQueries().forEach(rescorer -> searchRequestBuilder.addRescorer(getQueryRescorerBuilder(rescorer)));
if (query.getRequestCache() != null) {
searchRequestBuilder.setRequestCache(query.getRequestCache());
}
if (!query.getRuntimeFields().isEmpty()) {
Map<String, Object> runtimeMappings = new HashMap<>();
query.getRuntimeFields().forEach(runtimeField -> {
runtimeMappings.put(runtimeField.getName(), runtimeField.getMapping());
});
searchRequestBuilder.setRuntimeMappings(runtimeMappings);
}
if (query.getScrollTime() != null) {
searchRequestBuilder.setScroll(TimeValue.timeValueMillis(query.getScrollTime().toMillis()));
}
return searchRequestBuilder;
}
private void prepareNativeSearch(NativeSearchQuery query, SearchSourceBuilder sourceBuilder) {
if (!query.getScriptFields().isEmpty()) {
@ -1179,36 +776,6 @@ public class RequestFactory {
}
}
private void prepareNativeSearch(SearchRequestBuilder searchRequestBuilder, NativeSearchQuery nativeSearchQuery) {
if (!isEmpty(nativeSearchQuery.getScriptFields())) {
for (ScriptField scriptedField : nativeSearchQuery.getScriptFields()) {
searchRequestBuilder.addScriptField(scriptedField.fieldName(), scriptedField.script());
}
}
if (nativeSearchQuery.getCollapseBuilder() != null) {
searchRequestBuilder.setCollapse(nativeSearchQuery.getCollapseBuilder());
}
if (!isEmpty(nativeSearchQuery.getIndicesBoost())) {
for (IndexBoost indexBoost : nativeSearchQuery.getIndicesBoost()) {
searchRequestBuilder.addIndexBoost(indexBoost.getIndexName(), indexBoost.getBoost());
}
}
if (!isEmpty(nativeSearchQuery.getAggregations())) {
nativeSearchQuery.getAggregations().forEach(searchRequestBuilder::addAggregation);
}
if (!isEmpty(nativeSearchQuery.getPipelineAggregations())) {
nativeSearchQuery.getPipelineAggregations().forEach(searchRequestBuilder::addAggregation);
}
if (nativeSearchQuery.getSuggestBuilder() != null) {
searchRequestBuilder.suggest(nativeSearchQuery.getSuggestBuilder());
}
}
@SuppressWarnings("rawtypes")
private void prepareSort(Query query, SearchSourceBuilder sourceBuilder,
@Nullable ElasticsearchPersistentEntity<?> entity) {
@ -1402,80 +969,6 @@ public class RequestFactory {
return updateRequest;
}
public UpdateRequestBuilder updateRequestBuilderFor(Client client, UpdateQuery query, IndexCoordinates index) {
String indexName = index.getIndexName();
UpdateRequestBuilder updateRequestBuilder = client.prepareUpdate(indexName, IndexCoordinates.TYPE, query.getId());
if (query.getScript() != null) {
Map<String, Object> params = query.getParams();
if (params == null) {
params = new HashMap<>();
}
Script script = new Script(getScriptType(query.getScriptType()), query.getLang(), query.getScript(), params);
updateRequestBuilder.setScript(script);
}
if (query.getDocument() != null) {
updateRequestBuilder.setDoc(query.getDocument());
}
if (query.getUpsert() != null) {
updateRequestBuilder.setUpsert(query.getUpsert());
}
if (query.getRouting() != null) {
updateRequestBuilder.setRouting(query.getRouting());
}
if (query.getScriptedUpsert() != null) {
updateRequestBuilder.setScriptedUpsert(query.getScriptedUpsert());
}
if (query.getDocAsUpsert() != null) {
updateRequestBuilder.setDocAsUpsert(query.getDocAsUpsert());
}
if (query.getFetchSource() != null) {
updateRequestBuilder.setFetchSource(query.getFetchSource());
}
if (query.getFetchSourceIncludes() != null || query.getFetchSourceExcludes() != null) {
List<String> includes = query.getFetchSourceIncludes() != null ? query.getFetchSourceIncludes()
: Collections.emptyList();
List<String> excludes = query.getFetchSourceExcludes() != null ? query.getFetchSourceExcludes()
: Collections.emptyList();
updateRequestBuilder.setFetchSource(includes.toArray(new String[0]), excludes.toArray(new String[0]));
}
if (query.getIfSeqNo() != null) {
updateRequestBuilder.setIfSeqNo(query.getIfSeqNo());
}
if (query.getIfPrimaryTerm() != null) {
updateRequestBuilder.setIfPrimaryTerm(query.getIfPrimaryTerm());
}
if (query.getRefreshPolicy() != null) {
updateRequestBuilder.setRefreshPolicy(RequestFactory.toElasticsearchRefreshPolicy(query.getRefreshPolicy()));
}
if (query.getRetryOnConflict() != null) {
updateRequestBuilder.setRetryOnConflict(query.getRetryOnConflict());
}
if (query.getTimeout() != null) {
updateRequestBuilder.setTimeout(query.getTimeout());
}
if (query.getWaitForActiveShards() != null) {
updateRequestBuilder.setWaitForActiveShards(ActiveShardCount.parseString(query.getWaitForActiveShards()));
}
return updateRequestBuilder;
}
public UpdateByQueryRequest updateByQueryRequest(UpdateQuery query, IndexCoordinates index) {
String indexName = index.getIndexName();
@ -1547,79 +1040,6 @@ public class RequestFactory {
return updateByQueryRequest;
}
public UpdateByQueryRequestBuilder updateByQueryRequestBuilder(Client client, UpdateQuery query,
IndexCoordinates index) {
String indexName = index.getIndexName();
final UpdateByQueryRequestBuilder updateByQueryRequestBuilder = new UpdateByQueryRequestBuilder(client,
UpdateByQueryAction.INSTANCE);
updateByQueryRequestBuilder.source(indexName);
updateByQueryRequestBuilder.script(getScript(query));
if (query.getAbortOnVersionConflict() != null) {
updateByQueryRequestBuilder.abortOnVersionConflict(query.getAbortOnVersionConflict());
}
if (query.getBatchSize() != null) {
updateByQueryRequestBuilder.source().setSize(query.getBatchSize());
}
if (query.getQuery() != null) {
final Query queryQuery = query.getQuery();
updateByQueryRequestBuilder.filter(getQuery(queryQuery));
if (queryQuery.getIndicesOptions() != null) {
updateByQueryRequestBuilder.source()
.setIndicesOptions(toElasticsearchIndicesOptions(queryQuery.getIndicesOptions()));
}
if (queryQuery.getScrollTime() != null) {
updateByQueryRequestBuilder.source()
.setScroll(TimeValue.timeValueMillis(queryQuery.getScrollTime().toMillis()));
}
}
if (query.getMaxDocs() != null) {
updateByQueryRequestBuilder.maxDocs(query.getMaxDocs());
}
if (query.getMaxRetries() != null) {
updateByQueryRequestBuilder.setMaxRetries(query.getMaxRetries());
}
if (query.getPipeline() != null) {
updateByQueryRequestBuilder.setPipeline(query.getPipeline());
}
if (query.getRefreshPolicy() != null) {
updateByQueryRequestBuilder.refresh(query.getRefreshPolicy() == RefreshPolicy.IMMEDIATE);
}
if (query.getRequestsPerSecond() != null) {
updateByQueryRequestBuilder.setRequestsPerSecond(query.getRequestsPerSecond());
}
if (query.getRouting() != null) {
updateByQueryRequestBuilder.source().setRouting(query.getRouting());
}
if (query.getShouldStoreResult() != null) {
updateByQueryRequestBuilder.setShouldStoreResult(query.getShouldStoreResult());
}
if (query.getSlices() != null) {
updateByQueryRequestBuilder.setSlices(query.getSlices());
}
if (query.getTimeout() != null) {
updateByQueryRequestBuilder.source()
.setTimeout(TimeValue.parseTimeValue(query.getTimeout(), getClass().getSimpleName() + ".timeout"));
}
return updateByQueryRequestBuilder;
}
// endregion
// region helper functions

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/ResponseConverter.java
View File

@ -14,7 +14,7 @@
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import java.util.ArrayList;
import java.util.Collections;

1
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/RestIndexTemplate.java
View File

@ -40,7 +40,6 @@ import org.elasticsearch.client.indices.PutMappingRequest;
import org.elasticsearch.cluster.metadata.MappingMetadata;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.AbstractIndexTemplate;
import org.springframework.data.elasticsearch.core.IndexInformation;
import org.springframework.data.elasticsearch.core.IndexOperations;

290
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/TransportIndexTemplate.java
View File

@ -1,290 +0,0 @@
/*
* Copyright 2019-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequestBuilder;
import org.elasticsearch.action.admin.indices.alias.get.GetAliasesRequest;
import org.elasticsearch.action.admin.indices.create.CreateIndexRequestBuilder;
import org.elasticsearch.action.admin.indices.delete.DeleteIndexRequest;
import org.elasticsearch.action.admin.indices.exists.indices.IndicesExistsRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexRequest;
import org.elasticsearch.action.admin.indices.get.GetIndexResponse;
import org.elasticsearch.action.admin.indices.mapping.get.GetMappingsRequest;
import org.elasticsearch.action.admin.indices.mapping.put.PutMappingRequestBuilder;
import org.elasticsearch.action.admin.indices.refresh.RefreshRequest;
import org.elasticsearch.action.admin.indices.settings.get.GetSettingsRequest;
import org.elasticsearch.action.admin.indices.settings.get.GetSettingsResponse;
import org.elasticsearch.action.admin.indices.template.delete.DeleteIndexTemplateRequest;
import org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesRequest;
import org.elasticsearch.action.admin.indices.template.get.GetIndexTemplatesResponse;
import org.elasticsearch.action.admin.indices.template.put.PutIndexTemplateRequest;
import org.elasticsearch.client.Client;
import org.elasticsearch.cluster.metadata.AliasMetadata;
import org.elasticsearch.cluster.metadata.IndexTemplateMetadata;
import org.elasticsearch.cluster.metadata.MappingMetadata;
import org.elasticsearch.common.collect.ImmutableOpenMap;
import org.elasticsearch.common.compress.CompressedXContent;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.AbstractIndexTemplate;
import org.springframework.data.elasticsearch.core.IndexInformation;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.index.AliasActions;
import org.springframework.data.elasticsearch.core.index.AliasData;
import org.springframework.data.elasticsearch.core.index.DeleteTemplateRequest;
import org.springframework.data.elasticsearch.core.index.ExistsTemplateRequest;
import org.springframework.data.elasticsearch.core.index.GetTemplateRequest;
import org.springframework.data.elasticsearch.core.index.PutTemplateRequest;
import org.springframework.data.elasticsearch.core.index.Settings;
import org.springframework.data.elasticsearch.core.index.TemplateData;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* {@link IndexOperations} implementation using the TransportClient.
*
* @author Peter-Josef Meisch
* @author Sascha Woo
* @author George Popides
* @since 4.0
*/
class TransportIndexTemplate extends AbstractIndexTemplate implements IndexOperations {
private static final Logger LOGGER = LoggerFactory.getLogger(TransportIndexTemplate.class);
private final Client client;
public TransportIndexTemplate(Client client, ElasticsearchConverter elasticsearchConverter, Class<?> boundClass) {
super(elasticsearchConverter, boundClass);
this.client = client;
}
public TransportIndexTemplate(Client client, ElasticsearchConverter elasticsearchConverter,
IndexCoordinates boundIndex) {
super(elasticsearchConverter, boundIndex);
this.client = client;
}
@Override
protected boolean doCreate(IndexCoordinates index, Map<String, Object> settings, @Nullable Document mapping) {
CreateIndexRequestBuilder createIndexRequestBuilder = requestFactory.createIndexRequestBuilder(client, index,
settings, mapping);
return createIndexRequestBuilder.execute().actionGet().isAcknowledged();
}
@Override
protected boolean doDelete(IndexCoordinates index) {
Assert.notNull(index, "No index defined for delete operation");
if (doExists(index)) {
DeleteIndexRequest deleteIndexRequest = requestFactory.deleteIndexRequest(index);
return client.admin().indices().delete(deleteIndexRequest).actionGet().isAcknowledged();
}
return false;
}
@Override
protected boolean doExists(IndexCoordinates index) {
IndicesExistsRequest indicesExistsRequest = requestFactory.indicesExistsRequest(index);
return client.admin().indices().exists(indicesExistsRequest).actionGet().isExists();
}
@Override
protected boolean doPutMapping(IndexCoordinates index, Document mapping) {
Assert.notNull(index, "No index defined for putMapping()");
PutMappingRequestBuilder requestBuilder = requestFactory.putMappingRequestBuilder(client, index, mapping);
return requestBuilder.execute().actionGet().isAcknowledged();
}
@Override
protected Map<String, Object> doGetMapping(IndexCoordinates index) {
Assert.notNull(index, "No index defined for getMapping()");
GetMappingsRequest mappingsRequest = requestFactory.getMappingsRequest(client, index);
ImmutableOpenMap<String, ImmutableOpenMap<String, MappingMetadata>> mappings = client.admin().indices().getMappings( //
mappingsRequest).actionGet() //
.getMappings();
if (mappings == null || mappings.size() == 0) {
return Collections.emptyMap();
}
if (mappings.size() > 1) {
LOGGER.warn("more than one mapping returned for " + index.getIndexName());
}
// we have at least one, take the first from the iterator
return mappings.iterator().next().value.get(IndexCoordinates.TYPE).getSourceAsMap();
}
@Override
protected Map<String, Set<AliasData>> doGetAliases(@Nullable String[] aliasNames, @Nullable String[] indexNames) {
GetAliasesRequest getAliasesRequest = requestFactory.getAliasesRequest(aliasNames, indexNames);
ImmutableOpenMap<String, List<AliasMetadata>> aliases = client.admin().indices().getAliases(getAliasesRequest)
.actionGet().getAliases();
Map<String, Set<AliasMetadata>> aliasesResponse = new LinkedHashMap<>();
aliases.keysIt().forEachRemaining(index -> aliasesResponse.put(index, new HashSet<>(aliases.get(index))));
return ResponseConverter.aliasDatas(aliasesResponse);
}
@Override
public boolean alias(AliasActions aliasActions) {
IndicesAliasesRequestBuilder indicesAliasesRequestBuilder = requestFactory.indicesAliasesRequestBuilder(client,
aliasActions);
return indicesAliasesRequestBuilder.execute().actionGet().isAcknowledged();
}
@Override
protected Settings doGetSettings(IndexCoordinates index, boolean includeDefaults) {
Assert.notNull(index, "index must not be null");
GetSettingsRequest getSettingsRequest = requestFactory.getSettingsRequest(index, includeDefaults);
GetSettingsResponse response = client.admin() //
.indices() //
.getSettings(getSettingsRequest) //
.actionGet();
return ResponseConverter.fromSettingsResponse(response, index.getIndexName());
}
@Override
protected void doRefresh(IndexCoordinates index) {
Assert.notNull(index, "index must not be null");
RefreshRequest request = requestFactory.refreshRequest(index);
client.admin().indices().refresh(request).actionGet();
}
@Override
public boolean putTemplate(PutTemplateRequest putTemplateRequest) {
Assert.notNull(putTemplateRequest, "putTemplateRequest must not be null");
PutIndexTemplateRequest putIndexTemplateRequest = requestFactory.putIndexTemplateRequest(client,
putTemplateRequest);
return client.admin().indices().putTemplate(putIndexTemplateRequest).actionGet().isAcknowledged();
}
@Override
public TemplateData getTemplate(GetTemplateRequest getTemplateRequest) {
Assert.notNull(getTemplateRequest, "getTemplateRequest must not be null");
GetIndexTemplatesRequest getIndexTemplatesRequest = requestFactory.getIndexTemplatesRequest(client,
getTemplateRequest);
GetIndexTemplatesResponse getIndexTemplatesResponse = client.admin().indices()
.getTemplates(getIndexTemplatesRequest).actionGet();
for (IndexTemplateMetadata indexTemplateMetadata : getIndexTemplatesResponse.getIndexTemplates()) {
if (indexTemplateMetadata.getName().equals(getTemplateRequest.getTemplateName())) {
Settings settings = new Settings();
org.elasticsearch.common.settings.Settings templateSettings = indexTemplateMetadata.settings();
templateSettings.keySet().forEach(key -> settings.put(key, templateSettings.get(key)));
Map<String, AliasData> aliases = new LinkedHashMap<>();
ImmutableOpenMap<String, AliasMetadata> aliasesResponse = indexTemplateMetadata.aliases();
Iterator<String> keysItAliases = aliasesResponse.keysIt();
while (keysItAliases.hasNext()) {
String key = keysItAliases.next();
aliases.put(key, ResponseConverter.toAliasData(aliasesResponse.get(key)));
}
Map<String, String> mappingsDoc = new LinkedHashMap<>();
ImmutableOpenMap<String, CompressedXContent> mappingsResponse = indexTemplateMetadata.mappings();
Iterator<String> keysItMappings = mappingsResponse.keysIt();
while (keysItMappings.hasNext()) {
String key = keysItMappings.next();
mappingsDoc.put(key, mappingsResponse.get(key).string());
}
String mappingsJson = mappingsDoc.get("_doc");
Document mapping = null;
if (mappingsJson != null) {
try {
mapping = Document.from((Map<String, ? extends Object>) Document.parse(mappingsJson).get("_doc"));
} catch (Exception e) {
LOGGER.warn("Got invalid mappings JSON: {}", mappingsJson);
}
}
TemplateData templateData = TemplateData.builder()
.withIndexPatterns(indexTemplateMetadata.patterns().toArray(new String[0])) //
.withSettings(settings) //
.withMapping(mapping) //
.withAliases(aliases) //
.withOrder(indexTemplateMetadata.order()) //
.withVersion(indexTemplateMetadata.version()).build();
return templateData;
}
}
return null;
}
@Override
public boolean existsTemplate(ExistsTemplateRequest existsTemplateRequest) {
Assert.notNull(existsTemplateRequest, "existsTemplateRequest must not be null");
// client.admin().indices() has no method for checking the existence
return getTemplate(new GetTemplateRequest(existsTemplateRequest.getTemplateName())) != null;
}
@Override
public boolean deleteTemplate(DeleteTemplateRequest deleteTemplateRequest) {
Assert.notNull(deleteTemplateRequest, "deleteTemplateRequest must not be null");
DeleteIndexTemplateRequest deleteIndexTemplateRequest = requestFactory.deleteIndexTemplateRequest(client,
deleteTemplateRequest);
return client.admin().indices().deleteTemplate(deleteIndexTemplateRequest).actionGet().isAcknowledged();
}
@Override
public List<IndexInformation> getInformation(IndexCoordinates index) {
Assert.notNull(index, "index must not be null");
GetIndexRequest getIndexRequest = new GetIndexRequest();
getIndexRequest.indices(index.getIndexNames());
GetIndexResponse getIndexResponse = client.admin().indices().getIndex(getIndexRequest).actionGet();
return ResponseConverter.getIndexInformations(getIndexResponse);
}
}

104
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/client/ClusterNodes.java
View File

@ -1,104 +0,0 @@
/*
* Copyright 2018-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.backend.elasticsearch7.client;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
import java.util.stream.Collectors;
import org.elasticsearch.common.transport.TransportAddress;
import org.springframework.data.util.Streamable;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;
/**
* Value object to represent a list of cluster nodes.
*
* @author Oliver Gierke
* @since 3.1
* @deprecated only used in {@link TransportClientFactoryBean}.
*/
@SuppressWarnings("DeprecatedIsStillUsed")
@Deprecated
class ClusterNodes implements Streamable<TransportAddress> {
public static ClusterNodes DEFAULT = ClusterNodes.of("127.0.0.1:9300");
private static final String COLON = ":";
private static final String COMMA = ",";
private final List<TransportAddress> clusterNodes;
/**
* Creates a new {@link ClusterNodes} by parsing the given source.
*
* @param source must not be {@literal null} or empty.
*/
private ClusterNodes(String source) {
Assert.hasText(source, "Cluster nodes source must not be null or empty!");
String[] nodes = StringUtils.delimitedListToStringArray(source, COMMA);
this.clusterNodes = Arrays.stream(nodes).map(node -> {
String[] segments = StringUtils.delimitedListToStringArray(node, COLON);
Assert.isTrue(segments.length == 2,
() -> String.format("Invalid cluster node %s in %s! Must be in the format host:port!", node, source));
String host = segments[0].trim();
String port = segments[1].trim();
Assert.hasText(host, () -> String.format("No host name given cluster node %s!", node));
Assert.hasText(port, () -> String.format("No port given in cluster node %s!", node));
return new TransportAddress(toInetAddress(host), Integer.parseInt(port));
}).collect(Collectors.toList());
}
/**
* Creates a new {@link ClusterNodes} by parsing the given source. The expected format is a comma separated list of
* host-port-combinations separated by a colon: {@code host:port,host:port,…}.
*
* @param source must not be {@literal null} or empty.
*/
public static ClusterNodes of(String source) {
return new ClusterNodes(source);
}
/*
* (non-Javadoc)
* @see java.lang.Iterable#iterator()
*/
@Override
public Iterator<TransportAddress> iterator() {
return clusterNodes.iterator();
}
private static InetAddress toInetAddress(String host) {
try {
return InetAddress.getByName(host);
} catch (UnknownHostException o_O) {
throw new IllegalArgumentException(o_O);
}
}
}

158
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/client/TransportClientFactoryBean.java
View File

@ -1,158 +0,0 @@
/*
* Copyright 2013-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.backend.elasticsearch7.client;
import java.util.Properties;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.beans.factory.DisposableBean;
import org.springframework.beans.factory.FactoryBean;
import org.springframework.beans.factory.FactoryBeanNotInitializedException;
import org.springframework.beans.factory.InitializingBean;
import org.springframework.lang.Nullable;
/**
* TransportClientFactoryBean
*
* @author Rizwan Idrees
* @author Mohsin Husen
* @author Jakub Vavrik
* @author Piotr Betkier
* @author Ilkang Na
* @author Oliver Gierke
* @author Peter-Josef Meisch
* @deprecated as of 4.0
*/
@Deprecated
public class TransportClientFactoryBean implements FactoryBean<TransportClient>, InitializingBean, DisposableBean {
private static final Logger logger = LoggerFactory.getLogger(TransportClientFactoryBean.class);
private ClusterNodes clusterNodes = ClusterNodes.of("127.0.0.1:9300");
private String clusterName = "elasticsearch";
private Boolean clientTransportSniff = true;
private Boolean clientIgnoreClusterName = Boolean.FALSE;
private String clientPingTimeout = "5s";
private String clientNodesSamplerInterval = "5s";
private @Nullable TransportClient client;
private @Nullable Properties properties;
@Override
public void destroy() {
try {
logger.info("Closing elasticSearch client");
if (client != null) {
client.close();
}
} catch (final Exception e) {
logger.error("Error closing ElasticSearch client: ", e);
}
}
@Override
public TransportClient getObject() {
if (clientTransportSniff == null) {
throw new FactoryBeanNotInitializedException();
}
return client;
}
@Override
public Class<TransportClient> getObjectType() {
return TransportClient.class;
}
@Override
public boolean isSingleton() {
return true;
}
@Override
public void afterPropertiesSet() throws Exception {
buildClient();
}
protected void buildClient() {
client = new PreBuiltTransportClient(settings());
clusterNodes.stream() //
.peek(it -> logger.info("Adding transport node : " + it.toString())) //
.forEach(client::addTransportAddress);
client.connectedNodes();
}
private Settings settings() {
if (properties != null) {
Settings.Builder builder = Settings.builder();
properties.forEach((key, value) -> {
builder.put(key.toString(), value.toString());
});
return builder.build();
}
return Settings.builder().put("cluster.name", clusterName).put("client.transport.sniff", clientTransportSniff)
.put("client.transport.ignore_cluster_name", clientIgnoreClusterName)
.put("client.transport.ping_timeout", clientPingTimeout)
.put("client.transport.nodes_sampler_interval", clientNodesSamplerInterval).build();
}
public void setClusterNodes(String clusterNodes) {
this.clusterNodes = ClusterNodes.of(clusterNodes);
}
public void setClusterName(String clusterName) {
this.clusterName = clusterName;
}
public void setClientTransportSniff(Boolean clientTransportSniff) {
this.clientTransportSniff = clientTransportSniff;
}
public String getClientNodesSamplerInterval() {
return clientNodesSamplerInterval;
}
public void setClientNodesSamplerInterval(String clientNodesSamplerInterval) {
this.clientNodesSamplerInterval = clientNodesSamplerInterval;
}
public String getClientPingTimeout() {
return clientPingTimeout;
}
public void setClientPingTimeout(String clientPingTimeout) {
this.clientPingTimeout = clientPingTimeout;
}
public Boolean getClientIgnoreClusterName() {
return clientIgnoreClusterName;
}
public void setClientIgnoreClusterName(Boolean clientIgnoreClusterName) {
this.clientIgnoreClusterName = clientIgnoreClusterName;
}
public void setProperties(Properties properties) {
this.properties = properties;
}
}

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/client/reactive/DefaultReactiveElasticsearchClient.java
View File

@ -103,6 +103,7 @@ import org.elasticsearch.search.suggest.Suggest;
import org.reactivestreams.Publisher;
import org.springframework.data.elasticsearch.RestStatusException;
import org.springframework.data.elasticsearch.UncategorizedElasticsearchException;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.backend.elasticsearch7.client.reactive.ReactiveElasticsearchClient.Cluster;
import org.springframework.data.elasticsearch.backend.elasticsearch7.client.reactive.ReactiveElasticsearchClient.Indices;
import org.springframework.data.elasticsearch.backend.elasticsearch7.client.util.NamedXContents;
@ -116,7 +117,6 @@ import org.springframework.data.elasticsearch.client.reactive.ReactiveRestClient
import org.springframework.data.elasticsearch.client.reactive.RequestBodyEncodingException;
import org.springframework.data.elasticsearch.client.reactive.WebClientProvider;
import org.springframework.data.elasticsearch.client.util.ScrollState;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.query.ByQueryResponse;
import org.springframework.data.util.Lazy;
import org.springframework.http.HttpHeaders;

3
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/client/reactive/package-info.java Normal file
View File

@ -0,0 +1,3 @@
@org.springframework.lang.NonNullApi
@org.springframework.lang.NonNullFields
package org.springframework.data.elasticsearch.backend.elasticsearch7.client.reactive;

3
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/client/util/package-info.java Normal file
View File

@ -0,0 +1,3 @@
@org.springframework.lang.NonNullApi
@org.springframework.lang.NonNullFields
package org.springframework.data.elasticsearch.backend.elasticsearch7.client.util;

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/cluster/DefaultClusterOperations.java
View File

@ -19,7 +19,7 @@ import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest;
import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse;
import org.elasticsearch.client.RequestOptions;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.cluster.ClusterHealth;
import org.springframework.data.elasticsearch.core.cluster.ClusterOperations;

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/cluster/DefaultReactiveClusterOperations.java
View File

@ -18,7 +18,7 @@ package org.springframework.data.elasticsearch.backend.elasticsearch7.cluster;
import reactor.core.publisher.Mono;
import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.cluster.ClusterHealth;
import org.springframework.data.elasticsearch.core.cluster.ReactiveClusterOperations;

47
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/cluster/DefaultTransportClusterOperations.java
View File

@ -1,47 +0,0 @@
/*
* Copyright 2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.backend.elasticsearch7.cluster;
import org.elasticsearch.action.admin.cluster.health.ClusterHealthRequest;
import org.elasticsearch.action.admin.cluster.health.ClusterHealthResponse;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.cluster.ClusterHealth;
import org.springframework.data.elasticsearch.core.cluster.ClusterOperations;
/**
* Default implementation of {@link ClusterOperations} using the
* {@link org.elasticsearch.client.transport.TransportClient}.
*
* @author Peter-Josef Meisch
* @since 4.2
*/
public class DefaultTransportClusterOperations implements ClusterOperations {
private final ElasticsearchTemplate template;
public DefaultTransportClusterOperations(ElasticsearchTemplate template) {
this.template = template;
}
@Override
public ClusterHealth health() {
ClusterHealthResponse clusterHealthResponse = template.getClient().admin().cluster()
.health(new ClusterHealthRequest()).actionGet();
return ResponseConverter.clusterHealth(clusterHealthResponse);
}
}

14
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/cluster/ElasticsearchClusterOperations.java
View File

@ -16,7 +16,6 @@
package org.springframework.data.elasticsearch.backend.elasticsearch7.cluster;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchRestTemplate;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.cluster.ClusterOperations;
import org.springframework.util.Assert;
@ -38,17 +37,4 @@ public class ElasticsearchClusterOperations {
return new DefaultClusterOperations(template);
}
/**
* Creates a ClusterOperations for a {@link ElasticsearchTemplate}.
*
* @param template the template, must not be {@literal null}
* @return ClusterOperations
*/
public static ClusterOperations forTemplate(ElasticsearchTemplate template) {
Assert.notNull(template, "template must not be null");
return new DefaultTransportClusterOperations(template);
}
}

3
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/config/package-info.java Normal file
View File

@ -0,0 +1,3 @@
@org.springframework.lang.NonNullApi
@org.springframework.lang.NonNullFields
package org.springframework.data.elasticsearch.backend.elasticsearch7.config;

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/document/DocumentAdapters.java
View File

@ -39,7 +39,7 @@ import org.elasticsearch.common.text.Text;
import org.elasticsearch.index.get.GetResult;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ResponseConverter;
import org.springframework.data.elasticsearch.core.MultiGetItem;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.document.Explanation;

2
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/document/SearchDocumentResponse.java
View File

@ -25,7 +25,7 @@ import org.elasticsearch.common.text.Text;
import org.elasticsearch.search.SearchHit;
import org.elasticsearch.search.SearchHits;
import org.elasticsearch.search.aggregations.Aggregations;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ElasticsearchAggregations;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchAggregations;
import org.springframework.data.elasticsearch.core.AggregationsContainer;
import org.springframework.data.elasticsearch.core.document.SearchDocument;
import org.springframework.data.elasticsearch.core.suggest.response.CompletionSuggestion;

3
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/document/package-info.java Normal file
View File

@ -0,0 +1,3 @@
@org.springframework.lang.NonNullApi
@org.springframework.lang.NonNullFields
package org.springframework.data.elasticsearch.backend.elasticsearch7.document;

3
src/main/java/org/springframework/data/elasticsearch/backend/elasticsearch7/query/package-info.java Normal file
View File

@ -0,0 +1,3 @@
@org.springframework.lang.NonNullApi
@org.springframework.lang.NonNullFields
package org.springframework.data.elasticsearch.backend.elasticsearch7.query;

1
src/main/java/org/springframework/data/elasticsearch/config/ElasticsearchNamespaceHandler.java
View File

@ -35,7 +35,6 @@ public class ElasticsearchNamespaceHandler extends NamespaceHandlerSupport {
RepositoryBeanDefinitionParser parser = new RepositoryBeanDefinitionParser(extension);
registerBeanDefinitionParser("repositories", parser);
registerBeanDefinitionParser("transport-client", new TransportClientBeanDefinitionParser());
registerBeanDefinitionParser("rest-client", new RestClientBeanDefinitionParser());
}
}

59
src/main/java/org/springframework/data/elasticsearch/config/TransportClientBeanDefinitionParser.java
View File

@ -1,59 +0,0 @@
/*
* Copyright 2013-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.config;
import org.springframework.beans.factory.support.AbstractBeanDefinition;
import org.springframework.beans.factory.support.BeanDefinitionBuilder;
import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
import org.springframework.beans.factory.xml.ParserContext;
import org.springframework.data.elasticsearch.backend.elasticsearch7.client.TransportClientFactoryBean;
import org.w3c.dom.Element;
/**
* TransportClientBeanDefinitionParser
*
* @author Rizwan Idrees
* @author Mohsin Husen
* @deprecated as of 4.0
*/
@Deprecated
public class TransportClientBeanDefinitionParser extends AbstractBeanDefinitionParser {
@Override
protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
BeanDefinitionBuilder builder = BeanDefinitionBuilder.rootBeanDefinition(TransportClientFactoryBean.class);
setConfigurations(element, builder);
return getSourcedBeanDefinition(builder, element, parserContext);
}
private void setConfigurations(Element element, BeanDefinitionBuilder builder) {
builder.addPropertyValue("clusterNodes", element.getAttribute("cluster-nodes"));
builder.addPropertyValue("clusterName", element.getAttribute("cluster-name"));
builder.addPropertyValue("clientTransportSniff", Boolean.valueOf(element.getAttribute("client-transport-sniff")));
builder.addPropertyValue("clientIgnoreClusterName",
Boolean.valueOf(element.getAttribute("client-transport-ignore-cluster-name")));
builder.addPropertyValue("clientPingTimeout", element.getAttribute("client-transport-ping-timeout"));
builder.addPropertyValue("clientNodesSamplerInterval",
element.getAttribute("client-transport-nodes-sampler-interval"));
}
private AbstractBeanDefinition getSourcedBeanDefinition(BeanDefinitionBuilder builder, Element source,
ParserContext context) {
AbstractBeanDefinition definition = builder.getBeanDefinition();
definition.setSource(context.extractSource(source));
return definition;
}
}

69
src/main/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplate.java
View File

@ -20,14 +20,15 @@ import java.util.Arrays;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.stream.Collectors;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.data.convert.EntityReader;
import org.springframework.data.elasticsearch.backend.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.backend.elasticsearch7.document.SearchDocumentResponse;
import org.springframework.data.elasticsearch.clients.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter;
import org.springframework.data.elasticsearch.core.document.Document;
@ -59,9 +60,9 @@ import org.springframework.util.Assert;
/**
* This class contains methods that are common to different implementations of the {@link ElasticsearchOperations}
* interface that use different clients, like TransportClient, RestHighLevelClient and the next Java client from
* Elasticsearch or some future implementation that might use an Opensearch client. This class must not contain imports
* or use classes that are specific to one of these implementations.
* interface that use different clients, like RestHighLevelClient and the next Java client from Elasticsearch or some
* future implementation that might use an Opensearch client. This class must not contain imports or use classes that
* are specific to one of these implementations.
* <p>
* <strong>Note:</strong> Although this class is public, it is not considered to be part of the official Spring Data
* Elasticsearch API and so might change at any time.
@ -75,25 +76,27 @@ import org.springframework.util.Assert;
*/
public abstract class AbstractElasticsearchTemplate implements ElasticsearchOperations, ApplicationContextAware {
@Nullable protected ElasticsearchConverter elasticsearchConverter;
@Nullable protected RequestFactory requestFactory;
@Nullable protected EntityOperations entityOperations;
protected ElasticsearchConverter elasticsearchConverter;
protected RequestFactory requestFactory;
protected EntityOperations entityOperations;
@Nullable protected EntityCallbacks entityCallbacks;
@Nullable protected RefreshPolicy refreshPolicy;
@Nullable protected RoutingResolver routingResolver;
protected RoutingResolver routingResolver;
// region Initialization
protected void initialize(ElasticsearchConverter elasticsearchConverter) {
public AbstractElasticsearchTemplate() {
this(null);
}
Assert.notNull(elasticsearchConverter, "elasticsearchConverter must not be null.");
public AbstractElasticsearchTemplate(@Nullable ElasticsearchConverter elasticsearchConverter) {
this.elasticsearchConverter = elasticsearchConverter;
this.elasticsearchConverter = elasticsearchConverter != null ? elasticsearchConverter
: createElasticsearchConverter();
MappingContext<? extends ElasticsearchPersistentEntity<?>, ElasticsearchPersistentProperty> mappingContext = this.elasticsearchConverter
.getMappingContext();
this.entityOperations = new EntityOperations(mappingContext);
this.routingResolver = new DefaultRoutingResolver((SimpleElasticsearchMappingContext) mappingContext);
this.routingResolver = new DefaultRoutingResolver(mappingContext);
requestFactory = new RequestFactory(elasticsearchConverter);
requestFactory = new RequestFactory(this.elasticsearchConverter);
// initialize the VersionInfo class in the initialization phase
// noinspection ResultOfMethodCallIgnored
@ -117,9 +120,13 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
return copy;
}
/**
* must return a copy of this instance that will for example be used to set a custom routing resolver without
* modifying the original object.
*/
protected abstract AbstractElasticsearchTemplate doCopy();
protected ElasticsearchConverter createElasticsearchConverter() {
private ElasticsearchConverter createElasticsearchConverter() {
MappingElasticsearchConverter mappingElasticsearchConverter = new MappingElasticsearchConverter(
new SimpleElasticsearchMappingContext());
mappingElasticsearchConverter.afterPropertiesSet();
@ -195,9 +202,8 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
IndexQuery query = getIndexQuery(entityAfterBeforeConvert);
doIndex(query, index);
T entityAfterAfterSave = (T) maybeCallbackAfterSave(query.getObject(), index);
return entityAfterAfterSave;
// noinspection unchecked
return (T) maybeCallbackAfterSave(Objects.requireNonNull(query.getObject()), index);
}
@Override
@ -226,8 +232,8 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
return Collections.emptyList();
}
List<IndexedObjectInformation> indexedObjectInformations = bulkIndex(indexQueries, index);
Iterator<IndexedObjectInformation> iterator = indexedObjectInformations.iterator();
List<IndexedObjectInformation> indexedObjectInformationList = bulkIndex(indexQueries, index);
Iterator<IndexedObjectInformation> iterator = indexedObjectInformationList.iterator();
// noinspection unchecked
return indexQueries.stream() //
@ -236,8 +242,9 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
.collect(Collectors.toList()); //
}
@SafeVarargs
@Override
public <T> Iterable<T> save(T... entities) {
public final <T> Iterable<T> save(T... entities) {
return save(Arrays.asList(entities));
}
@ -299,7 +306,9 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
@Override
public String delete(Object entity, IndexCoordinates index) {
return this.delete(getEntityId(entity), index);
String entityId = getEntityId(entity);
Assert.notNull(entityId, "entity must have an if that is notnull");
return this.delete(entityId, index);
}
@Override
@ -348,11 +357,11 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
maybeCallbackBeforeConvertWithQueries(queries, index);
List<IndexedObjectInformation> indexedObjectInformations = doBulkOperation(queries, bulkOptions, index);
List<IndexedObjectInformation> indexedObjectInformationList = doBulkOperation(queries, bulkOptions, index);
maybeCallbackAfterSaveWithQueries(queries, index);
return indexedObjectInformations;
return indexedObjectInformationList;
}
public abstract List<IndexedObjectInformation> doBulkOperation(List<?> queries, BulkOptions bulkOptions,
@ -450,9 +459,6 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
* @since 4.0
*/
public RequestFactory getRequestFactory() {
Assert.notNull(requestFactory, "requestfactory not initialized");
return requestFactory;
}
@ -501,8 +507,7 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
}
// noinspection unchecked
T updatedEntity = (T) propertyAccessor.getBean();
return updatedEntity;
return (T) propertyAccessor.getBean();
}
return entity;
}
@ -559,6 +564,7 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
id = elasticsearchConverter.convertId(id);
}
// noinspection ConstantConditions
IndexQueryBuilder builder = new IndexQueryBuilder() //
.withId(id) //
.withObject(entity);
@ -569,6 +575,7 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
builder.withSeqNoPrimaryTerm(seqNoPrimaryTerm);
} else {
// version cannot be used together with seq_no and primary_term
// noinspection ConstantConditions
builder.withVersion(getEntityVersion(entity));
}
@ -686,7 +693,7 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
// endregion
protected void updateIndexedObjectsWithQueries(List<?> queries,
List<IndexedObjectInformation> indexedObjectInformations) {
List<IndexedObjectInformation> indexedObjectInformationList) {
for (int i = 0; i < queries.size(); i++) {
Object query = queries.get(i);
@ -696,7 +703,7 @@ public abstract class AbstractElasticsearchTemplate implements ElasticsearchOper
Object queryObject = indexQuery.getObject();
if (queryObject != null) {
indexQuery.setObject(updateIndexedObject(queryObject, indexedObjectInformations.get(i)));
indexQuery.setObject(updateIndexedObject(queryObject, indexedObjectInformationList.get(i)));
}
}
}

2
src/main/java/org/springframework/data/elasticsearch/core/AbstractIndexTemplate.java
View File

@ -25,7 +25,7 @@ import org.springframework.core.annotation.AnnotatedElementUtils;
import org.springframework.dao.InvalidDataAccessApiUsageException;
import org.springframework.data.elasticsearch.UncategorizedElasticsearchException;
import org.springframework.data.elasticsearch.annotations.Mapping;
import org.springframework.data.elasticsearch.clients.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.backend.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.index.AliasData;

2
src/main/java/org/springframework/data/elasticsearch/core/query/highlight/HighlightCommonParameters.java
View File

@ -21,7 +21,7 @@ import org.springframework.util.Assert;
* @author Peter-Josef Meisch
* @since 4.3
*/
abstract public class HighlightCommonParameters {
public abstract class HighlightCommonParameters {
private final String boundaryChars;
private final int boundaryMaxScan;
private final String boundaryScanner;

2
src/test/java/org/springframework/data/elasticsearch/JUnit5SampleRestClientBasedTests.java → src/test/java/org/springframework/data/elasticsearch/JUnit5SampleRestTemplateBasedTests.java
View File

@ -35,7 +35,7 @@ import org.springframework.test.context.ContextConfiguration;
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
@DisplayName("a sample JUnit 5 test with rest client")
public class JUnit5SampleRestClientBasedTests {
public class JUnit5SampleRestTemplateBasedTests {
@Autowired private ElasticsearchOperations elasticsearchOperations;

47
src/test/java/org/springframework/data/elasticsearch/JUnit5SampleTransportClientBasedTests.java
View File

@ -1,47 +0,0 @@
/*
* Copyright 2019-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch;
import static org.assertj.core.api.Assertions.*;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.test.context.ContextConfiguration;
/**
* class demonstrating the setup of a JUnit 5 test in Spring Data Elasticsearch that uses the transport client. The
* ContextConfiguration must include the {@link ElasticsearchTemplateConfiguration} class
*
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
@DisplayName("a sample JUnit 5 test with transport client")
public class JUnit5SampleTransportClientBasedTests {
@Autowired private ElasticsearchOperations elasticsearchOperations;
@Test
@DisplayName("should have a ElasticsearchTemplate")
void shouldHaveATemplate() {
assertThat(elasticsearchOperations).isNotNull().isInstanceOf(ElasticsearchTemplate.class);
}
}

17
src/test/java/org/springframework/data/elasticsearch/TransportFoobarIntegrationTest.java
View File

@ -1,17 +0,0 @@
package org.springframework.data.elasticsearch;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.IntegrationtestEnvironment;
import org.springframework.test.context.ContextConfiguration;
/**
* This class should only run when the cluster is an Elasticsearch cluster.
*
* @author Peter-Josef Meisch
*/
@EnabledIfSystemProperty(named = IntegrationtestEnvironment.SYSTEM_PROPERTY, matches = "(?i)elasticsearch")
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
@DisplayName("foobar integration with transport client")
public class TransportFoobarIntegrationTest extends FoobarIntegrationTest {}

2
src/test/java/org/springframework/data/elasticsearch/backend/elasticsearch7/CriteriaQueryMappingUnitTests.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import static org.skyscreamer.jsonassert.JSONAssert.*;

2
src/test/java/org/springframework/data/elasticsearch/backend/elasticsearch7/CriteriaQueryProcessorUnitTests.java
View File

@ -13,7 +13,7 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import static org.skyscreamer.jsonassert.JSONAssert.*;

107
src/test/java/org/springframework/data/elasticsearch/backend/elasticsearch7/RequestFactoryTests.java
View File

@ -13,11 +13,10 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.clients.elasticsearch7;
package org.springframework.data.elasticsearch.backend.elasticsearch7;
import static org.assertj.core.api.Assertions.*;
import static org.elasticsearch.index.query.QueryBuilders.*;
import static org.mockito.Mockito.*;
import static org.skyscreamer.jsonassert.JSONAssert.*;
import java.io.IOException;
@ -27,13 +26,8 @@ import java.util.HashSet;
import org.elasticsearch.action.DocWriteRequest;
import org.elasticsearch.action.admin.indices.alias.IndicesAliasesRequest;
import org.elasticsearch.action.index.IndexAction;
import org.elasticsearch.action.index.IndexRequest;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.action.search.SearchAction;
import org.elasticsearch.action.search.SearchRequest;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.indices.PutIndexTemplateRequest;
import org.elasticsearch.common.lucene.search.function.CombineFunction;
import org.elasticsearch.common.lucene.search.function.FunctionScoreQuery;
@ -49,13 +43,13 @@ import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.core.convert.support.GenericConversionService;
import org.springframework.data.annotation.Id;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter;
import org.springframework.data.elasticsearch.core.geo.GeoPoint;
import org.springframework.data.elasticsearch.core.index.AliasAction;
@ -69,7 +63,6 @@ import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
import org.springframework.data.elasticsearch.core.query.GeoDistanceOrder;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.IndexQueryBuilder;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.core.query.RescorerQuery;
import org.springframework.data.elasticsearch.core.query.RescorerQuery.ScoreMode;
@ -88,8 +81,6 @@ class RequestFactoryTests {
@Nullable private static RequestFactory requestFactory;
@Nullable private static MappingElasticsearchConverter converter;
@Mock private Client client;
@BeforeAll
static void setUpAll() {
SimpleElasticsearchMappingContext mappingContext = new SimpleElasticsearchMappingContext();
@ -151,7 +142,7 @@ class RequestFactoryTests {
}
@Test // DATAES-449
void shouldAddRouting() throws JSONException {
void shouldAddRouting() {
String route = "route66";
CriteriaQuery query = new CriteriaQuery(new Criteria("lastName").is("Smith"));
query.setRoute(route);
@ -172,18 +163,6 @@ class RequestFactoryTests {
assertThat(searchRequest.source().size()).isEqualTo(RequestFactory.INDEX_MAX_RESULT_WINDOW);
}
@Test // DATAES-765
void shouldAddMaxQueryWindowForUnpagedToRequestBuilder() {
when(client.prepareSearch(any())).thenReturn(new SearchRequestBuilder(client, SearchAction.INSTANCE));
Query query = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).withPageable(Pageable.unpaged()).build();
SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, Person.class,
IndexCoordinates.of("persons"));
assertThat(searchRequestBuilder.request().source().from()).isEqualTo(0);
assertThat(searchRequestBuilder.request().source().size()).isEqualTo(RequestFactory.INDEX_MAX_RESULT_WINDOW);
}
@Test // DATAES-799
void shouldIncludeSeqNoAndPrimaryTermFromIndexQueryToIndexRequest() {
IndexQuery query = new IndexQuery();
@ -198,23 +177,7 @@ class RequestFactoryTests {
}
@Test // DATAES-799
void shouldIncludeSeqNoAndPrimaryTermFromIndexQueryToIndexRequestBuilder() {
when(client.prepareIndex(anyString(), anyString()))
.thenReturn(new IndexRequestBuilder(client, IndexAction.INSTANCE));
IndexQuery query = new IndexQuery();
query.setObject(new Person());
query.setSeqNo(1L);
query.setPrimaryTerm(2L);
IndexRequestBuilder builder = requestFactory.indexRequestBuilder(client, query, IndexCoordinates.of("persons"));
assertThat(builder.request().ifSeqNo()).isEqualTo(1L);
assertThat(builder.request().ifPrimaryTerm()).isEqualTo(2L);
}
@Test // DATAES-799
void shouldNotRequestSeqNoAndPrimaryTermViaSearchRequestWhenEntityClassDoesNotContainSeqNoPrimaryTermProperty() {
void shouldNotRequestSeqNoAndPrimaryTermWhenEntityClassDoesNotContainSeqNoPrimaryTermProperty() {
Query query = new NativeSearchQueryBuilder().build();
SearchRequest request = requestFactory.searchRequest(query, Person.class, IndexCoordinates.of("persons"));
@ -223,7 +186,7 @@ class RequestFactoryTests {
}
@Test // DATAES-799
void shouldRequestSeqNoAndPrimaryTermViaSearchRequestWhenEntityClassContainsSeqNoPrimaryTermProperty() {
void shouldRequestSeqNoAndPrimaryTermWhenEntityClassContainsSeqNoPrimaryTermProperty() {
Query query = new NativeSearchQueryBuilder().build();
SearchRequest request = requestFactory.searchRequest(query, EntityWithSeqNoPrimaryTerm.class,
@ -233,7 +196,7 @@ class RequestFactoryTests {
}
@Test // DATAES-799
void shouldNotRequestSeqNoAndPrimaryTermViaSearchRequestWhenEntityClassIsNull() {
void shouldNotRequestSeqNoAndPrimaryTermWhenEntityClassIsNull() {
Query query = new NativeSearchQueryBuilder().build();
SearchRequest request = requestFactory.searchRequest(query, null, IndexCoordinates.of("persons"));
@ -241,39 +204,6 @@ class RequestFactoryTests {
assertThat(request.source().seqNoAndPrimaryTerm()).isNull();
}
@Test // DATAES-799
void shouldNotRequestSeqNoAndPrimaryTermViaSearchRequestBuilderWhenEntityClassDoesNotContainSeqNoPrimaryTermProperty() {
when(client.prepareSearch(any())).thenReturn(new SearchRequestBuilder(client, SearchAction.INSTANCE));
Query query = new NativeSearchQueryBuilder().build();
SearchRequestBuilder builder = requestFactory.searchRequestBuilder(client, query, Person.class,
IndexCoordinates.of("persons"));
assertThat(builder.request().source().seqNoAndPrimaryTerm()).isNull();
}
@Test // DATAES-799
void shouldRequestSeqNoAndPrimaryTermViaSearchRequestBuilderWhenEntityClassContainsSeqNoPrimaryTermProperty() {
when(client.prepareSearch(any())).thenReturn(new SearchRequestBuilder(client, SearchAction.INSTANCE));
Query query = new NativeSearchQueryBuilder().build();
SearchRequestBuilder builder = requestFactory.searchRequestBuilder(client, query, EntityWithSeqNoPrimaryTerm.class,
IndexCoordinates.of("seqNoPrimaryTerm"));
assertThat(builder.request().source().seqNoAndPrimaryTerm()).isTrue();
}
@Test // DATAES-799
void shouldNotRequestSeqNoAndPrimaryTermViaSearchRequestBuilderWhenEntityClassIsNull() {
when(client.prepareSearch(any())).thenReturn(new SearchRequestBuilder(client, SearchAction.INSTANCE));
Query query = new NativeSearchQueryBuilder().build();
SearchRequestBuilder builder = requestFactory.searchRequestBuilder(client, query, null,
IndexCoordinates.of("persons"));
assertThat(builder.request().source().seqNoAndPrimaryTerm()).isNull();
}
@Test // DATAES-864
void shouldBuildIndicesAliasRequest() throws IOException, JSONException {
@ -497,19 +427,6 @@ class RequestFactoryTests {
assertThat(searchRequest.source().timeout().getMillis()).isEqualTo(Duration.ofSeconds(1).toMillis());
}
@Test // DATAES-1003
@DisplayName("should set timeout to requestbuilder")
void shouldSetTimeoutToRequestBuilder() {
when(client.prepareSearch(any())).thenReturn(new SearchRequestBuilder(client, SearchAction.INSTANCE));
Query query = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).withTimeout(Duration.ofSeconds(1)).build();
SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, Person.class,
IndexCoordinates.of("persons"));
assertThat(searchRequestBuilder.request().source().timeout().getMillis())
.isEqualTo(Duration.ofSeconds(1).toMillis());
}
private String requestToString(ToXContent request) throws IOException {
return XContentHelper.toXContent(request, XContentType.JSON, true).utf8ToString();
}
@ -599,47 +516,35 @@ class RequestFactoryTests {
@DisplayName("should not set request_cache on default SearchRequest")
void shouldNotSetRequestCacheOnDefaultSearchRequest() {
when(client.prepareSearch(any())).thenReturn(new SearchRequestBuilder(client, SearchAction.INSTANCE));
Query query = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
SearchRequest searchRequest = requestFactory.searchRequest(query, Person.class, IndexCoordinates.of("persons"));
SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, Person.class,
IndexCoordinates.of("persons"));
assertThat(searchRequest.requestCache()).isNull();
assertThat(searchRequestBuilder.request().requestCache()).isNull();
}
@Test // #1564
@DisplayName("should set request_cache true on SearchRequest")
void shouldSetRequestCacheTrueOnSearchRequest() {
when(client.prepareSearch(any())).thenReturn(new SearchRequestBuilder(client, SearchAction.INSTANCE));
Query query = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
query.setRequestCache(true);
SearchRequest searchRequest = requestFactory.searchRequest(query, Person.class, IndexCoordinates.of("persons"));
SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, Person.class,
IndexCoordinates.of("persons"));
assertThat(searchRequest.requestCache()).isTrue();
assertThat(searchRequestBuilder.request().requestCache()).isTrue();
}
@Test // #1564
@DisplayName("should set request_cache false on SearchRequest")
void shouldSetRequestCacheFalseOnSearchRequest() {
when(client.prepareSearch(any())).thenReturn(new SearchRequestBuilder(client, SearchAction.INSTANCE));
Query query = new NativeSearchQueryBuilder().withQuery(matchAllQuery()).build();
query.setRequestCache(false);
SearchRequest searchRequest = requestFactory.searchRequest(query, Person.class, IndexCoordinates.of("persons"));
SearchRequestBuilder searchRequestBuilder = requestFactory.searchRequestBuilder(client, query, Person.class,
IndexCoordinates.of("persons"));
assertThat(searchRequest.requestCache()).isFalse();
assertThat(searchRequestBuilder.request().requestCache()).isFalse();
}
// region entities

87
src/test/java/org/springframework/data/elasticsearch/backend/elasticsearch7/client/ClusterNodesUnitTests.java
View File

@ -1,87 +0,0 @@
/*
* Copyright 2018-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.backend.elasticsearch7.client;
import static org.assertj.core.api.Assertions.*;
import org.junit.jupiter.api.Test;
/**
* Unit tests for {@link ClusterNodes}.
*
* @author Oliver Gierke
*/
public class ClusterNodesUnitTests {
@Test // DATAES-470
public void parsesSingleClusterNode() {
ClusterNodes nodes = ClusterNodes.DEFAULT;
assertThat(nodes).hasSize(1) //
.first().satisfies(it -> {
assertThat(it.getAddress()).isEqualTo("127.0.0.1");
assertThat(it.getPort()).isEqualTo(9300);
});
}
@Test // DATAES-470
public void parsesMultiClusterNode() {
ClusterNodes nodes = ClusterNodes.of("127.0.0.1:1234,10.1.0.1:5678");
assertThat(nodes.stream()).hasSize(2); //
assertThat(nodes.stream()).element(0).satisfies(it -> {
assertThat(it.getAddress()).isEqualTo("127.0.0.1");
assertThat(it.getPort()).isEqualTo(1234);
});
assertThat(nodes.stream()).element(1).satisfies(it -> {
assertThat(it.getAddress()).isEqualTo("10.1.0.1");
assertThat(it.getPort()).isEqualTo(5678);
});
}
@Test // DATAES-470
public void rejectsEmptyHostName() {
assertThatExceptionOfType(IllegalArgumentException.class) //
.isThrownBy(() -> ClusterNodes.of(":8080")) //
.withMessageContaining("host");
}
@Test // DATAES-470
public void rejectsEmptyPort() {
assertThatExceptionOfType(IllegalArgumentException.class) //
.isThrownBy(() -> ClusterNodes.of("localhost:")) //
.withMessageContaining("port");
}
@Test // DATAES-470
public void rejectsMissingPort() {
assertThatExceptionOfType(IllegalArgumentException.class) //
.isThrownBy(() -> ClusterNodes.of("localhost")) //
.withMessageContaining("host:port");
}
@Test // DATAES-470
public void rejectsUnresolvableHost() {
assertThatExceptionOfType(IllegalArgumentException.class) //
.isThrownBy(() -> ClusterNodes.of("mylocalhost.invalid.:80"));
}
}

2
src/test/java/org/springframework/data/elasticsearch/config/AuditingIntegrationTest.java → src/test/java/org/springframework/data/elasticsearch/config/AuditingIntegrationTests.java
View File

@ -40,7 +40,7 @@ import org.springframework.lang.Nullable;
* @author Peter-Josef Meisch
* @author Roman Puchkovskiy
*/
public abstract class AuditingIntegrationTest {
public abstract class AuditingIntegrationTests {
public static AuditorAware<String> auditorProvider() {
return new AuditorAware<String>() {

4
src/test/java/org/springframework/data/elasticsearch/config/ElasticsearchRestAuditingIntegrationTest.java → src/test/java/org/springframework/data/elasticsearch/config/AuditingRestTemplateIntegrationTests.java
View File

@ -26,8 +26,8 @@ import org.springframework.test.context.ContextConfiguration;
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestAuditingIntegrationTest.Config.class })
public class ElasticsearchRestAuditingIntegrationTest extends AuditingIntegrationTest {
@ContextConfiguration(classes = { AuditingRestTemplateIntegrationTests.Config.class })
public class AuditingRestTemplateIntegrationTests extends AuditingIntegrationTests {
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchAuditing(auditorAwareRef = "auditorAware")

41
src/test/java/org/springframework/data/elasticsearch/config/ElasticsearchTransportAuditingIntegrationTest.java
View File

@ -1,41 +0,0 @@
/*
* Copyright 2020-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.config;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Import;
import org.springframework.data.domain.AuditorAware;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchTransportAuditingIntegrationTest.Config.class })
public class ElasticsearchTransportAuditingIntegrationTest extends AuditingIntegrationTest {
@Import({ ElasticsearchTemplateConfiguration.class })
@EnableElasticsearchAuditing(auditorAwareRef = "auditorAware")
static class Config {
@Bean
public AuditorAware<String> auditorAware() {
return auditorProvider();
}
}
}

10
src/test/java/org/springframework/data/elasticsearch/config/namespace/ElasticsearchNamespaceHandlerTests.java
View File

@ -25,7 +25,6 @@ import org.springframework.context.ApplicationContext;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.backend.elasticsearch7.client.RestClientFactoryBean;
import org.springframework.data.elasticsearch.backend.elasticsearch7.client.TransportClientFactoryBean;
import org.springframework.data.elasticsearch.junit.jupiter.Tags;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.test.context.ContextConfiguration;
@ -45,17 +44,8 @@ public class ElasticsearchNamespaceHandlerTests {
@Autowired private ApplicationContext context;
@Test
public void shouldCreateTransportClient() {
assertThat(context.getBean(TransportClientFactoryBean.class)).isNotNull();
assertThat(context.getBean(TransportClientFactoryBean.class)).isInstanceOf(TransportClientFactoryBean.class);
}
@Test
public void shouldCreateRepository() {
assertThat(context.getBean(TransportClientFactoryBean.class)).isNotNull();
assertThat(context.getBean(CreateIndexFalseRepository.class)).isInstanceOf(CreateIndexFalseRepository.class);
}

14
src/test/java/org/springframework/data/elasticsearch/config/nested/EnableNestedElasticsearchRepositoriesTests.java → src/test/java/org/springframework/data/elasticsearch/config/nested/EnableNestedElasticsearchRepositoriesIntegrationTests.java
View File

@ -25,8 +25,6 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Version;
import org.springframework.data.elasticsearch.annotations.Document;
@ -34,26 +32,16 @@ import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.ScriptedField;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.geo.GeoPoint;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.data.repository.Repository;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Kevin Leturc
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { EnableNestedElasticsearchRepositoriesTests.Config.class })
public class EnableNestedElasticsearchRepositoriesTests {
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchRepositories(basePackages = { "org.springframework.data.elasticsearch.config.nested" },
considerNestedRepositories = true)
static class Config {}
public abstract class EnableNestedElasticsearchRepositoriesIntegrationTests {
@Autowired(required = false) private SampleRepository nestedRepository;
@Autowired ElasticsearchOperations operations;

13
src/test/java/org/springframework/data/elasticsearch/config/nested/EnableNestedElasticsearchRepositoriesTransportTests.java → src/test/java/org/springframework/data/elasticsearch/config/nested/EnableNestedElasticsearchRepositoriesRestTemplateIntegrationTests.java
View File

@ -17,17 +17,20 @@ package org.springframework.data.elasticsearch.config.nested;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { EnableNestedElasticsearchRepositoriesTransportTests.Config.class })
public class EnableNestedElasticsearchRepositoriesTransportTests extends EnableNestedElasticsearchRepositoriesTests {
@ContextConfiguration(classes = { EnableNestedElasticsearchRepositoriesRestTemplateIntegrationTests.Config.class })
public class EnableNestedElasticsearchRepositoriesRestTemplateIntegrationTests
extends EnableNestedElasticsearchRepositoriesIntegrationTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@EnableElasticsearchRepositories(considerNestedRepositories = true)
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchRepositories(basePackages = { "org.springframework.data.elasticsearch.config.nested" },
considerNestedRepositories = true)
static class Config {}
}

9
src/test/java/org/springframework/data/elasticsearch/config/notnested/EnableElasticsearchRepositoriesTransportTests.java → src/test/java/org/springframework/data/elasticsearch/config/notnested/EnableElasticsearchRepositoriesRestTemplateTests.java
View File

@ -17,15 +17,16 @@ package org.springframework.data.elasticsearch.config.notnested;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
/**
* @author Peter-Josef Meisch
*/
public class EnableElasticsearchRepositoriesTransportTests extends EnableElasticsearchRepositoriesTests {
public class EnableElasticsearchRepositoriesRestTemplateTests extends EnableElasticsearchRepositoriesTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@EnableElasticsearchRepositories(considerNestedRepositories = true)
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchRepositories
static class Config {}
}

13
src/test/java/org/springframework/data/elasticsearch/config/notnested/EnableElasticsearchRepositoriesTests.java
View File

@ -29,8 +29,6 @@ import org.springframework.beans.BeansException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Version;
import org.springframework.data.elasticsearch.annotations.Document;
@ -41,14 +39,11 @@ import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.geo.GeoPoint;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.data.elasticsearch.utils.IndexInitializer;
import org.springframework.data.repository.Repository;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Rizwan Idrees
@ -58,8 +53,7 @@ import org.springframework.test.context.ContextConfiguration;
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { EnableElasticsearchRepositoriesTests.Config.class })
public class EnableElasticsearchRepositoriesTests implements ApplicationContextAware {
public abstract class EnableElasticsearchRepositoriesTests implements ApplicationContextAware {
@Nullable ApplicationContext context;
@ -69,11 +63,6 @@ public class EnableElasticsearchRepositoriesTests implements ApplicationContextA
this.context = applicationContext;
}
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchRepositories
static class Config {}
@Autowired ElasticsearchOperations operations;
private IndexOperations indexOperations;

2
src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchPartQueryTests.java
View File

@ -33,7 +33,7 @@ import org.mockito.junit.jupiter.MockitoExtension;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.clients.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.backend.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
import org.springframework.data.elasticsearch.core.convert.MappingElasticsearchConverter;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;

3
src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchRestTemplateCallbackTests.java
View File

@ -49,7 +49,7 @@ import org.springframework.data.elasticsearch.backend.elasticsearch7.Elasticsear
*/
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class ElasticsearchRestTemplateCallbackTests extends AbstractElasticsearchTemplateCallbackTests {
class ElasticsearchRestTemplateCallbackTests extends ElasticsearchTemplateCallbackTests {
@Mock private RestHighLevelClient client;
@ -103,6 +103,7 @@ class ElasticsearchRestTemplateCallbackTests extends AbstractElasticsearchTempla
MultiSearchResponse multiSearchResponse = new MultiSearchResponse(
new MultiSearchResponse.Item[] { multiSearchResponseItem }, 1L);
doReturn(multiSearchResponse).when(client).multiSearch(any(MultiSearchRequest.class), any());
doReturn(multiSearchResponse).when(client).msearch(any(MultiSearchRequest.class), any());
doReturn(searchResponse).when(multiSearchResponseItem).getResponse();
doReturn(searchResponse).when(client).scroll(any(SearchScrollRequest.class), any(RequestOptions.class));

4
src/test/java/org/springframework/data/elasticsearch/core/AbstractElasticsearchTemplateCallbackTests.java → src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateCallbackTests.java
View File

@ -30,6 +30,7 @@ import org.junit.jupiter.api.Test;
import org.mockito.Mock;
import org.mockito.Spy;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.document.Document;
import org.springframework.data.elasticsearch.core.event.AfterConvertCallback;
import org.springframework.data.elasticsearch.core.event.AfterSaveCallback;
@ -38,7 +39,6 @@ import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.BulkOptions;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.core.query.MoreLikeThisQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.mapping.callback.EntityCallbacks;
import org.springframework.data.util.CloseableIterator;
@ -48,7 +48,7 @@ import org.springframework.util.CollectionUtils;
/**
* @author Roman Puchkovskiy
*/
abstract class AbstractElasticsearchTemplateCallbackTests {
abstract class ElasticsearchTemplateCallbackTests {
protected AbstractElasticsearchTemplate template;

2
src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTemplateTests.java
View File

@ -83,10 +83,10 @@ import org.springframework.data.elasticsearch.annotations.JoinTypeRelations;
import org.springframework.data.elasticsearch.annotations.MultiField;
import org.springframework.data.elasticsearch.annotations.ScriptedField;
import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.backend.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.ScriptField;
import org.springframework.data.elasticsearch.clients.elasticsearch7.RequestFactory;
import org.springframework.data.elasticsearch.core.document.Explanation;
import org.springframework.data.elasticsearch.core.geo.GeoPoint;
import org.springframework.data.elasticsearch.core.index.AliasAction;

143
src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTransportTemplateCallbackTests.java
View File

@ -1,143 +0,0 @@
/*
* Copyright 2020-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.core;
import static org.mockito.Mockito.*;
import java.util.HashMap;
import org.elasticsearch.action.ActionFuture;
import org.elasticsearch.action.bulk.BulkItemResponse;
import org.elasticsearch.action.bulk.BulkRequestBuilder;
import org.elasticsearch.action.bulk.BulkResponse;
import org.elasticsearch.action.get.GetRequestBuilder;
import org.elasticsearch.action.get.GetResponse;
import org.elasticsearch.action.get.MultiGetItemResponse;
import org.elasticsearch.action.get.MultiGetRequestBuilder;
import org.elasticsearch.action.get.MultiGetResponse;
import org.elasticsearch.action.index.IndexRequestBuilder;
import org.elasticsearch.action.index.IndexResponse;
import org.elasticsearch.action.search.MultiSearchRequest;
import org.elasticsearch.action.search.MultiSearchResponse;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.search.SearchResponse;
import org.elasticsearch.action.search.SearchScrollRequestBuilder;
import org.elasticsearch.action.search.SearchType;
import org.elasticsearch.client.Client;
import org.elasticsearch.common.bytes.BytesArray;
import org.elasticsearch.core.TimeValue;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.extension.ExtendWith;
import org.mockito.Mock;
import org.mockito.junit.jupiter.MockitoExtension;
import org.mockito.junit.jupiter.MockitoSettings;
import org.mockito.quality.Strictness;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchTemplate;
/**
* @author Roman Puchkovskiy
*/
@ExtendWith(MockitoExtension.class)
@MockitoSettings(strictness = Strictness.LENIENT)
class ElasticsearchTransportTemplateCallbackTests extends AbstractElasticsearchTemplateCallbackTests {
@Mock private Client client;
@Mock private IndexRequestBuilder indexRequestBuilder;
@Mock private ActionFuture<IndexResponse> indexResponseActionFuture;
@Mock private IndexResponse indexResponse;
@Mock private BulkRequestBuilder bulkRequestBuilder;
@Mock private ActionFuture<BulkResponse> bulkResponseActionFuture;
@Mock private BulkResponse bulkResponse;
@Mock private BulkItemResponse bulkItemResponse;
@Mock private GetRequestBuilder getRequestBuilder;
@Mock private ActionFuture<GetResponse> getResponseActionFuture;
@Mock private GetResponse getResponse;
@Mock private MultiGetRequestBuilder multiGetRequestBuilder;
@Mock private ActionFuture<MultiGetResponse> multiGetResponseActionFuture;
@Mock private MultiGetResponse multiGetResponse;
@Mock private MultiGetItemResponse multiGetItemResponse;
@Mock private SearchRequestBuilder searchRequestBuilder;
@Mock private ActionFuture<SearchResponse> searchResponseActionFuture;
@Mock private ActionFuture<MultiSearchResponse> multiSearchResponseActionFuture;
@Mock private MultiSearchResponse.Item multiSearchResponseItem;
@Mock private SearchScrollRequestBuilder searchScrollRequestBuilder;
@BeforeEach
@SuppressWarnings("deprecation") // we know what we are testing
public void setUp() {
initTemplate(new ElasticsearchTemplate(client));
when(client.prepareIndex(anyString(), anyString(), anyString())).thenReturn(indexRequestBuilder);
doReturn(indexResponseActionFuture).when(indexRequestBuilder).execute();
when(indexResponseActionFuture.actionGet()).thenReturn(indexResponse);
doReturn("response-id").when(indexResponse).getId();
when(client.prepareBulk()).thenReturn(bulkRequestBuilder);
doReturn(bulkResponseActionFuture).when(bulkRequestBuilder).execute();
when(bulkResponseActionFuture.actionGet()).thenReturn(bulkResponse);
doReturn(new BulkItemResponse[] { bulkItemResponse, bulkItemResponse }).when(bulkResponse).getItems();
doReturn("response-id").when(bulkItemResponse).getId();
when(client.prepareGet(anyString(), any(), any())).thenReturn(getRequestBuilder);
doReturn(getResponseActionFuture).when(getRequestBuilder).execute();
when(getResponseActionFuture.actionGet()).thenReturn(getResponse);
doReturn(true).when(getResponse).isExists();
doReturn(false).when(getResponse).isSourceEmpty();
doReturn(new HashMap<String, Object>() {
{
put("id", "init");
put("firstname", "luke");
}
}).when(getResponse).getSourceAsMap();
when(client.prepareMultiGet()).thenReturn(multiGetRequestBuilder);
doReturn(multiGetResponseActionFuture).when(multiGetRequestBuilder).execute();
when(multiGetResponseActionFuture.actionGet()).thenReturn(multiGetResponse);
doReturn(new MultiGetItemResponse[] { multiGetItemResponse, multiGetItemResponse }).when(multiGetResponse)
.getResponses();
doReturn(getResponse).when(multiGetItemResponse).getResponse();
when(client.prepareSearch(anyVararg())).thenReturn(searchRequestBuilder);
doReturn(searchRequestBuilder).when(searchRequestBuilder).setSearchType(any(SearchType.class));
doReturn(searchRequestBuilder).when(searchRequestBuilder).setVersion(anyBoolean());
doReturn(searchRequestBuilder).when(searchRequestBuilder).setTrackScores(anyBoolean());
doReturn(searchRequestBuilder).when(searchRequestBuilder).setScroll(any(TimeValue.class));
doReturn(searchResponseActionFuture).when(searchRequestBuilder).execute();
when(searchResponseActionFuture.actionGet()).thenReturn(searchResponse);
when(searchResponseActionFuture.actionGet(anyString())).thenReturn(searchResponse);
doReturn(nSearchHits(2)).when(searchResponse).getHits();
doReturn("scroll-id").when(searchResponse).getScrollId();
doReturn(new BytesArray(new byte[8])).when(searchHit).getSourceRef();
doReturn(new HashMap<String, Object>() {
{
put("id", "init");
put("firstname", "luke");
}
}).when(searchHit).getSourceAsMap();
when(client.multiSearch(any(MultiSearchRequest.class))).thenReturn(multiSearchResponseActionFuture);
MultiSearchResponse multiSearchResponse = new MultiSearchResponse(
new MultiSearchResponse.Item[] { multiSearchResponseItem }, 1L);
when(multiSearchResponseActionFuture.actionGet()).thenReturn(multiSearchResponse);
doReturn(searchResponse).when(multiSearchResponseItem).getResponse();
when(client.prepareSearchScroll(anyString())).thenReturn(searchScrollRequestBuilder);
doReturn(searchScrollRequestBuilder).when(searchScrollRequestBuilder).setScroll(any(TimeValue.class));
doReturn(searchResponseActionFuture).when(searchScrollRequestBuilder).execute();
}
}

234
src/test/java/org/springframework/data/elasticsearch/core/ElasticsearchTransportTemplateTests.java
View File

@ -1,234 +0,0 @@
/*
* Copyright 2018-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.core;
import static org.assertj.core.api.Assertions.*;
import static org.elasticsearch.index.query.QueryBuilders.*;
import static org.skyscreamer.jsonassert.JSONAssert.*;
import static org.springframework.data.elasticsearch.annotations.FieldType.*;
import static org.springframework.data.elasticsearch.utils.IdGenerator.*;
import java.lang.Object;
import java.time.Duration;
import java.util.Collections;
import java.util.HashMap;
import java.util.Map;
import org.elasticsearch.action.search.SearchRequestBuilder;
import org.elasticsearch.action.support.ActiveShardCount;
import org.elasticsearch.action.support.WriteRequest;
import org.elasticsearch.action.update.UpdateRequestBuilder;
import org.elasticsearch.client.Client;
import org.elasticsearch.core.TimeValue;
import org.elasticsearch.index.engine.DocumentMissingException;
import org.elasticsearch.index.reindex.UpdateByQueryRequestBuilder;
import org.elasticsearch.search.fetch.subphase.FetchSourceContext;
import org.json.JSONException;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndicesOptions;
import org.springframework.data.elasticsearch.core.query.UpdateQuery;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.utils.IndexNameProvider;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
* @author Sascha Woo
* @author Farid Faoudi
*/
@ContextConfiguration(classes = { ElasticsearchTransportTemplateTests.Config.class })
@DisplayName("ElasticsearchTransportTemplate")
public class ElasticsearchTransportTemplateTests extends ElasticsearchTemplateTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
static class Config {
@Bean
IndexNameProvider indexNameProvider() {
return new IndexNameProvider("transport-template");
}
}
@Autowired private Client client;
@Test
public void shouldThrowExceptionIfDocumentDoesNotExistWhileDoingPartialUpdate() {
// when
org.springframework.data.elasticsearch.core.document.Document document = org.springframework.data.elasticsearch.core.document.Document
.create();
UpdateQuery updateQuery = UpdateQuery.builder(nextIdAsString()).withDocument(document).build();
assertThatThrownBy(() -> operations.update(updateQuery, IndexCoordinates.of(indexNameProvider.indexName())))
.isInstanceOf(DocumentMissingException.class);
}
@Override
@Test // DATAES-187
public void shouldUsePageableOffsetToSetFromInSearchRequest() {
// given
Pageable pageable = new PageRequest(1, 10, Sort.unsorted()) {
@Override
public long getOffset() {
return 30;
}
};
NativeSearchQuery query = new NativeSearchQueryBuilder() //
.withPageable(pageable) //
.build();
// when
SearchRequestBuilder searchRequestBuilder = getRequestFactory().searchRequestBuilder(client, query, null,
IndexCoordinates.of("test"));
// then
assertThat(searchRequestBuilder.request().source().from()).isEqualTo(30);
}
@Test // DATAES-768
void shouldUseAllOptionsFromUpdateQuery() {
Map<String, Object> doc = new HashMap<>();
doc.put("id", "1");
doc.put("message", "test");
org.springframework.data.elasticsearch.core.document.Document document = org.springframework.data.elasticsearch.core.document.Document
.from(doc);
UpdateQuery updateQuery = UpdateQuery.builder("1") //
.withDocument(document) //
.withIfSeqNo(42) //
.withIfPrimaryTerm(13) //
.withScript("script")//
.withLang("lang") //
.withRefreshPolicy(RefreshPolicy.WAIT_UNTIL) //
.withRetryOnConflict(7) //
.withTimeout("4711s") //
.withWaitForActiveShards("all").withFetchSourceIncludes(Collections.singletonList("incl")) //
.withFetchSourceExcludes(Collections.singletonList("excl")) //
.build();
UpdateRequestBuilder request = getRequestFactory().updateRequestBuilderFor(client, updateQuery,
IndexCoordinates.of("index"));
assertThat(request).isNotNull();
assertThat(request.request().ifSeqNo()).isEqualTo(42);
assertThat(request.request().ifPrimaryTerm()).isEqualTo(13);
assertThat(request.request().script().getIdOrCode()).isEqualTo("script");
assertThat(request.request().script().getLang()).isEqualTo("lang");
assertThat(request.request().getRefreshPolicy()).isEqualByComparingTo(WriteRequest.RefreshPolicy.WAIT_UNTIL);
assertThat(request.request().retryOnConflict()).isEqualTo(7);
assertThat(request.request().timeout()).isEqualByComparingTo(TimeValue.parseTimeValue("4711s", "test"));
assertThat(request.request().waitForActiveShards()).isEqualTo(ActiveShardCount.ALL);
FetchSourceContext fetchSourceContext = request.request().fetchSource();
assertThat(fetchSourceContext).isNotNull();
assertThat(fetchSourceContext.includes()).containsExactlyInAnyOrder("incl");
assertThat(fetchSourceContext.excludes()).containsExactlyInAnyOrder("excl");
}
@Test // DATAES-782
void shouldProvideClient() {
Client client = ((ElasticsearchTemplate) operations).getClient();
assertThat(client).isNotNull();
}
@Test // #1446
void shouldUseAllOptionsFromUpdateByQuery() throws JSONException {
NativeSearchQuery searchQuery = new NativeSearchQueryBuilder().withQuery(matchAllQuery()) //
.withIndicesOptions(IndicesOptions.LENIENT_EXPAND_OPEN) //
.build(); //
searchQuery.setScrollTime(Duration.ofMillis(1000));
UpdateQuery updateQuery = UpdateQuery.builder(searchQuery) //
.withAbortOnVersionConflict(true) //
.withBatchSize(10) //
.withMaxDocs(12) //
.withMaxRetries(3) //
.withPipeline("pipeline") //
.withRequestsPerSecond(5F) //
.withShouldStoreResult(false) //
.withSlices(4) //
.withScriptType(ScriptType.STORED) //
.withScriptName("script_name") //
.build(); //
String expectedSearchRequest = '{' + //
" \"size\": 10," + //
" \"query\": {" + //
" \"match_all\": {" + //
" \"boost\": 1.0" + //
" }" + //
" }" + //
'}'; //
// when
UpdateByQueryRequestBuilder request = getRequestFactory().updateByQueryRequestBuilder(client, updateQuery,
IndexCoordinates.of("index"));
// then
assertThat(request).isNotNull();
assertThat(request.request().getSearchRequest().indicesOptions()).usingRecursiveComparison()
.isEqualTo(IndicesOptions.LENIENT_EXPAND_OPEN);
assertThat(request.request().getScrollTime().getMillis()).isEqualTo(1000);
assertEquals(request.request().getSearchRequest().source().toString(), expectedSearchRequest, false);
assertThat(request.request().isAbortOnVersionConflict()).isTrue();
assertThat(request.request().getBatchSize()).isEqualTo(10);
assertThat(request.request().getMaxDocs()).isEqualTo(12);
assertThat(request.request().getPipeline()).isEqualTo("pipeline");
assertThat(request.request().getRequestsPerSecond()).isEqualTo(5F);
assertThat(request.request().getShouldStoreResult()).isFalse();
assertThat(request.request().getSlices()).isEqualTo(4);
assertThat(request.request().getScript().getIdOrCode()).isEqualTo("script_name");
assertThat(request.request().getScript().getType()).isEqualTo(org.elasticsearch.script.ScriptType.STORED);
}
@Document(indexName = "test-index-sample-core-transport-template")
static class SampleEntity {
@Nullable @Id private String id;
@Nullable @Field(type = Text, store = true, fielddata = true) private String type;
public String getId() {
return id;
}
public void setId(String id) {
this.id = id;
}
public String getType() {
return type;
}
public void setType(String type) {
this.type = type;
}
}
}

13
src/test/java/org/springframework/data/elasticsearch/core/InnerHitsTests.java → src/test/java/org/springframework/data/elasticsearch/core/InnerHitsIntegrationTests.java
View File

@ -31,19 +31,15 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.core.document.NestedMetaData;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.core.document.NestedMetaData;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* Testing the querying and parsing of inner_hits.
@ -51,15 +47,10 @@ import org.springframework.test.context.ContextConfiguration;
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { InnerHitsTests.Config.class })
public class InnerHitsTests {
public abstract class InnerHitsIntegrationTests {
public static final String INDEX_NAME = "tests-inner-hits";
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
@Autowired ElasticsearchOperations operations;
@Nullable IndexOperations indexOps;

8
src/test/java/org/springframework/data/elasticsearch/core/InnerHitsTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/InnerHitsRestTemplateIntegrationTests.java
View File

@ -17,15 +17,15 @@ package org.springframework.data.elasticsearch.core;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { InnerHitsTransportTests.Config.class })
public class InnerHitsTransportTests extends InnerHitsTests {
@ContextConfiguration(classes = { InnerHitsRestTemplateIntegrationTests.Config.class })
public class InnerHitsRestTemplateIntegrationTests extends InnerHitsIntegrationTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
}

17
src/test/java/org/springframework/data/elasticsearch/core/LogEntityTests.java → src/test/java/org/springframework/data/elasticsearch/core/LogEntityIntegrationTests.java
View File

@ -28,37 +28,28 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.dao.DataAccessException;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.DateFormat;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.utils.IndexInitializer;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* LogEntityTests
* LogEntityIntegrationTests
*
* @author Artur Konczak
* @author Mohsin Husen
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { LogEntityTests.Config.class })
public class LogEntityTests {
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
public abstract class LogEntityIntegrationTests {
private final IndexCoordinates index = IndexCoordinates.of("test-index-log-core");
@Autowired private ElasticsearchOperations operations;

13
src/test/java/org/springframework/data/elasticsearch/core/LogEntityTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/LogEntityRestTemplateIntegrationTests.java
View File

@ -15,24 +15,23 @@
*/
package org.springframework.data.elasticsearch.core;
import org.elasticsearch.ElasticsearchException;
import org.elasticsearch.ElasticsearchSecurityException;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.RestStatusException;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { LogEntityTransportTests.Config.class })
public class LogEntityTransportTests extends LogEntityTests {
@ContextConfiguration(classes = { LogEntityRestTemplateIntegrationTests.Config.class })
public class LogEntityRestTemplateIntegrationTests extends LogEntityIntegrationTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
@Override
protected Class<? extends Exception> invalidIpExceptionClass() {
return ElasticsearchException.class;
return RestStatusException.class;
}
}

2
src/test/java/org/springframework/data/elasticsearch/core/ReactiveElasticsearchTemplateIntegrationTests.java
View File

@ -70,11 +70,11 @@ import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.annotations.Mapping;
import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchAggregation;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ReactiveElasticsearchTemplate;
import org.springframework.data.elasticsearch.backend.elasticsearch7.client.reactive.ReactiveElasticsearchClient;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ElasticsearchAggregation;
import org.springframework.data.elasticsearch.core.document.Explanation;
import org.springframework.data.elasticsearch.core.index.AliasAction;
import org.springframework.data.elasticsearch.core.index.AliasActionParameters;

5
src/test/java/org/springframework/data/elasticsearch/core/SourceFilterIntegrationTests.java
View File

@ -32,17 +32,14 @@ import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.core.query.FetchSourceFilterBuilder;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.core.query.SourceFilter;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class SourceFilterIntegrationTests {
public abstract class SourceFilterIntegrationTests {
@Autowired private ElasticsearchOperations operations;
private IndexOperations indexOps;

6
src/test/java/org/springframework/data/elasticsearch/core/SourceFilterIntegrationTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/SourceFilterRestTemplateIntegrationTests.java
View File

@ -15,11 +15,11 @@
*/
package org.springframework.data.elasticsearch.core;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
public class SourceFilterIntegrationTransportTests extends SourceFilterIntegrationTests {}
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class SourceFilterRestTemplateIntegrationTests extends SourceFilterIntegrationTests {}

17
src/test/java/org/springframework/data/elasticsearch/core/aggregation/ElasticsearchTemplateAggregationTests.java → src/test/java/org/springframework/data/elasticsearch/core/aggregation/AggregationIntegrationTests.java
View File

@ -37,27 +37,23 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.InnerField;
import org.springframework.data.elasticsearch.annotations.MultiField;
import org.springframework.data.elasticsearch.clients.elasticsearch7.ElasticsearchAggregations;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchAggregations;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.AggregationsContainer;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.utils.IndexInitializer;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Rizwan Idrees
@ -67,12 +63,7 @@ import org.springframework.test.context.ContextConfiguration;
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchTemplateAggregationTests.Config.class })
public class ElasticsearchTemplateAggregationTests {
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
public abstract class AggregationIntegrationTests {
static final String RIZWAN_IDREES = "Rizwan Idrees";
static final String MOHSIN_HUSEN = "Mohsin Husen";

8
src/test/java/org/springframework/data/elasticsearch/core/aggregation/ElasticsearchTemplateAggregationTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/aggregation/AggregationRestTemplateIntegrationTests.java
View File

@ -17,17 +17,17 @@ package org.springframework.data.elasticsearch.core.aggregation;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateAggregationTransportTests.Config.class })
public class ElasticsearchTemplateAggregationTransportTests extends ElasticsearchTemplateAggregationTests {
@ContextConfiguration(classes = { AggregationRestTemplateIntegrationTests.Config.class })
public class AggregationRestTemplateIntegrationTests extends AggregationIntegrationTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchRepositories(considerNestedRepositories = true)
static class Config {}
}

5
src/test/java/org/springframework/data/elasticsearch/core/cluster/ClusterOperationsIntegrationTests.java
View File

@ -25,16 +25,13 @@ import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class ClusterOperationsIntegrationTests {
public abstract class ClusterOperationsIntegrationTests {
@Autowired private ElasticsearchOperations operations;
private ClusterOperations clusterOperations;

2
src/test/java/org/springframework/data/elasticsearch/core/cluster/ReactiveClusterOperationsIntegrationTests.java → src/test/java/org/springframework/data/elasticsearch/core/cluster/ClusterOperationsReactiveTemplateIntegrationTests.java
View File

@ -36,7 +36,7 @@ import org.springframework.test.context.ContextConfiguration;
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ReactiveElasticsearchRestTemplateConfiguration.class })
public class ReactiveClusterOperationsIntegrationTests {
public class ClusterOperationsReactiveTemplateIntegrationTests {
@Autowired private ReactiveElasticsearchOperations operations;
private ReactiveClusterOperations clusterOperations;

6
src/test/java/org/springframework/data/elasticsearch/core/cluster/ClusterOperationsTransportIntegrationTests.java → src/test/java/org/springframework/data/elasticsearch/core/cluster/ClusterOperationsRestTemplateIntegrationTests.java
View File

@ -15,11 +15,11 @@
*/
package org.springframework.data.elasticsearch.core.cluster;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
public class ClusterOperationsTransportIntegrationTests extends ClusterOperationsIntegrationTests {}
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class ClusterOperationsRestTemplateIntegrationTests extends ClusterOperationsIntegrationTests {}

7
src/test/java/org/springframework/data/elasticsearch/core/event/ElasticsearchOperationsCallbackIntegrationTest.java → src/test/java/org/springframework/data/elasticsearch/core/event/ElasticsearchOperationsCallbackIntegrationTests.java
View File

@ -48,7 +48,7 @@ import org.springframework.stereotype.Component;
* @author Roman Puchkovskiy
*/
@SpringIntegrationTest
abstract class ElasticsearchOperationsCallbackIntegrationTest {
abstract class ElasticsearchOperationsCallbackIntegrationTests {
private static final String INDEX = "test-operations-callback";
@Autowired private ElasticsearchOperations originalOperations;
@ -219,9 +219,8 @@ abstract class ElasticsearchOperationsCallbackIntegrationTest {
@Nullable @Id private String id;
@Nullable private String text;
@Nullable @JoinTypeRelations(relations = { @JoinTypeRelation(parent = "question",
children = { "answer" }) })
private JoinField<String> joinField;
@Nullable @JoinTypeRelations(relations = {
@JoinTypeRelation(parent = "question", children = { "answer" }) }) private JoinField<String> joinField;
@Nullable private SeqNoPrimaryTerm seqNoPrimaryTerm;

4
src/test/java/org/springframework/data/elasticsearch/core/event/ElasticsearchRestOperationsCallbackIntegrationTest.java → src/test/java/org/springframework/data/elasticsearch/core/event/ElasticsearchRestTemplateCallbackIntegrationTests.java
View File

@ -22,5 +22,5 @@ import org.springframework.test.context.ContextConfiguration;
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class,
ElasticsearchOperationsCallbackIntegrationTest.Config.class })
class ElasticsearchRestOperationsCallbackIntegrationTest extends ElasticsearchOperationsCallbackIntegrationTest {}
ElasticsearchOperationsCallbackIntegrationTests.Config.class })
class ElasticsearchRestTemplateCallbackIntegrationTests extends ElasticsearchOperationsCallbackIntegrationTests {}

25
src/test/java/org/springframework/data/elasticsearch/core/event/ElasticsearchTransportOperationsCallbackIntegrationTest.java
View File

@ -1,25 +0,0 @@
/*
* Copyright 2020-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.core.event;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class, ElasticsearchOperationsCallbackIntegrationTest.Config.class })
class ElasticsearchTransportOperationsCallbackIntegrationTest extends ElasticsearchOperationsCallbackIntegrationTest {}

13
src/test/java/org/springframework/data/elasticsearch/core/geo/ElasticsearchTemplateGeoTests.java → src/test/java/org/springframework/data/elasticsearch/core/geo/GeoIntegrationTests.java
View File

@ -26,11 +26,10 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.GeoPointField;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
@ -38,13 +37,10 @@ import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.Criteria;
import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.utils.IndexInitializer;
import org.springframework.data.geo.Point;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Rizwan Idrees
@ -58,12 +54,7 @@ import org.springframework.test.context.ContextConfiguration;
* Latitude , max Longitude , max Latitude
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchTemplateGeoTests.Config.class })
public class ElasticsearchTemplateGeoTests {
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
public abstract class GeoIntegrationTests {
private final IndexCoordinates locationMarkerIndex = IndexCoordinates.of("test-index-location-marker-core-geo");
private final IndexCoordinates authorMarkerIndex = IndexCoordinates.of("test-index-author-marker-core-geo");

10
src/test/java/org/springframework/data/elasticsearch/core/geo/GeoJsonIntegrationTest.java → src/test/java/org/springframework/data/elasticsearch/core/geo/GeoJsonIntegrationTests.java
View File

@ -32,19 +32,15 @@ import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.Criteria;
import org.springframework.data.elasticsearch.core.query.CriteriaQuery;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.geo.Point;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
@DisplayName("GeoJson integration test with REST client")
class GeoJsonIntegrationTest {
abstract class GeoJsonIntegrationTests {
@Autowired private ElasticsearchOperations operations;
@ -82,7 +78,7 @@ class GeoJsonIntegrationTest {
new Point(40, 40), //
new Point(30, 40), //
new Point(30, 30));
private final Area area30To40 = new Area("area30To40",geoShape30To40);
private final Area area30To40 = new Area("area30To40", geoShape30To40);
private final GeoJsonPolygon geoShape32To37 = GeoJsonPolygon.of( //
new Point(32, 32), //
@ -90,7 +86,7 @@ class GeoJsonIntegrationTest {
new Point(37, 37), //
new Point(32, 37), //
new Point(32, 32));
private final Area area32To37 = new Area("area32To37",geoShape30To40);
private final Area area32To37 = new Area("area32To37", geoShape30To40);
// endregion
// region setup

10
src/test/java/org/springframework/data/elasticsearch/core/geo/GeoJsonTransportIntegrationTest.java → src/test/java/org/springframework/data/elasticsearch/core/geo/GeoJsonRestTemplateIntegrationTests.java
View File

@ -16,14 +16,12 @@
package org.springframework.data.elasticsearch.core.geo;
import org.junit.jupiter.api.DisplayName;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
@DisplayName("GeoJson integration test with transport client")
public class GeoJsonTransportIntegrationTest extends GeoJsonIntegrationTest {}
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
@DisplayName("GeoJson integration test with REST client")
public class GeoJsonRestTemplateIntegrationTests extends GeoJsonIntegrationTests {}

8
src/test/java/org/springframework/data/elasticsearch/core/geo/ElasticsearchTemplateGeoTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/geo/GeoRestTemplateIntegrationTests.java
View File

@ -17,17 +17,17 @@ package org.springframework.data.elasticsearch.core.geo;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateGeoTransportTests.Config.class })
public class ElasticsearchTemplateGeoTransportTests extends ElasticsearchTemplateGeoTests {
@ContextConfiguration(classes = { GeoRestTemplateIntegrationTests.Config.class })
public class GeoRestTemplateIntegrationTests extends GeoIntegrationTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchRepositories(considerNestedRepositories = true)
static class Config {}
}

5
src/test/java/org/springframework/data/elasticsearch/core/index/IndexOperationIntegrationTests.java
View File

@ -32,17 +32,14 @@ import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexInformation;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author George Popides
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class IndexOperationIntegrationTests {
public abstract class IndexOperationIntegrationTests {
public static final String INDEX_NAME = "test-index-information-list";

6
src/test/java/org/springframework/data/elasticsearch/core/index/IndexOperationTransportIntegrationTests.java → src/test/java/org/springframework/data/elasticsearch/core/index/IndexOperationRestTemplateIntegrationTests.java
View File

@ -1,10 +1,10 @@
package org.springframework.data.elasticsearch.core.index;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author George Popides
*/
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
public class IndexOperationTransportIntegrationTests extends IndexOperationIntegrationTests {}
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class IndexOperationRestTemplateIntegrationTests extends IndexOperationIntegrationTests {}

5
src/test/java/org/springframework/data/elasticsearch/core/index/TemplateTests.java → src/test/java/org/springframework/data/elasticsearch/core/index/IndexTemplateIntegrationTests.java
View File

@ -32,17 +32,14 @@ import org.springframework.data.elasticsearch.annotations.Setting;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class TemplateTests {
public abstract class IndexTemplateIntegrationTests {
@Autowired ElasticsearchOperations operations;

6
src/test/java/org/springframework/data/elasticsearch/core/index/TemplateTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/index/IndexTemplateRestTemplateIntegrationTests.java
View File

@ -15,11 +15,11 @@
*/
package org.springframework.data.elasticsearch.core.index;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
public class TemplateTransportTests extends TemplateTests {}
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class IndexTemplateRestTemplateIntegrationTests extends IndexTemplateIntegrationTests {}

29
src/test/java/org/springframework/data/elasticsearch/core/mapping/FieldNamingStrategyIntegrationTest.java → src/test/java/org/springframework/data/elasticsearch/core/mapping/FieldNamingStrategyIntegrationTests.java
View File

@ -18,55 +18,30 @@ package org.springframework.data.elasticsearch.core.mapping;
import static org.assertj.core.api.Assertions.*;
import static org.elasticsearch.index.query.QueryBuilders.*;
import org.elasticsearch.client.RestHighLevelClient;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.DisplayName;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.mapping.model.FieldNamingStrategy;
import org.springframework.data.mapping.model.SnakeCaseFieldNamingStrategy;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { FieldNamingStrategyIntegrationTest.Config.class })
public class FieldNamingStrategyIntegrationTest {
public abstract class FieldNamingStrategyIntegrationTests {
@Autowired private ElasticsearchOperations operations;
@Configuration
static class Config extends ElasticsearchRestTemplateConfiguration {
@Override
@Bean
public ElasticsearchOperations elasticsearchOperations(ElasticsearchConverter elasticsearchConverter,
RestHighLevelClient elasticsearchClient) {
return super.elasticsearchOperations(elasticsearchConverter, elasticsearchClient);
}
@Override
protected FieldNamingStrategy fieldNamingStrategy() {
return new SnakeCaseFieldNamingStrategy();
}
}
@BeforeEach
void setUp() {
IndexOperations indexOps = this.operations.indexOps(Entity.class);

6
src/test/java/org/springframework/data/elasticsearch/core/mapping/FieldNamingStrategyIntegrationReactiveTest.java → src/test/java/org/springframework/data/elasticsearch/core/mapping/FieldNamingStrategyReactiveTemplateIntegrationTests.java
View File

@ -28,9 +28,9 @@ import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.ReactiveIndexOperations;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.junit.jupiter.ReactiveElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
@ -43,8 +43,8 @@ import org.springframework.test.context.ContextConfiguration;
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { FieldNamingStrategyIntegrationReactiveTest.Config.class })
public class FieldNamingStrategyIntegrationReactiveTest {
@ContextConfiguration(classes = { FieldNamingStrategyReactiveTemplateIntegrationTests.Config.class })
public class FieldNamingStrategyReactiveTemplateIntegrationTests {
@Autowired private ReactiveElasticsearchOperations operations;

20
src/test/java/org/springframework/data/elasticsearch/core/mapping/FieldNamingStrategyIntegrationTemplateTest.java → src/test/java/org/springframework/data/elasticsearch/core/mapping/FieldNamingStrategyRestTemplateIntegrationTests.java
View File

@ -15,8 +15,12 @@
*/
package org.springframework.data.elasticsearch.core.mapping;
import org.elasticsearch.client.RestHighLevelClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.mapping.model.FieldNamingStrategy;
import org.springframework.data.mapping.model.SnakeCaseFieldNamingStrategy;
import org.springframework.test.context.ContextConfiguration;
@ -24,16 +28,22 @@ import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { FieldNamingStrategyIntegrationTemplateTest.Config.class })
public class FieldNamingStrategyIntegrationTemplateTest extends FieldNamingStrategyIntegrationTest {
@ContextConfiguration(classes = { FieldNamingStrategyRestTemplateIntegrationTests.Config.class })
public class FieldNamingStrategyRestTemplateIntegrationTests extends FieldNamingStrategyIntegrationTests {
@Configuration
static class Config extends ElasticsearchTemplateConfiguration {
static class Config extends ElasticsearchRestTemplateConfiguration {
@Override
@Bean
public ElasticsearchOperations elasticsearchOperations(ElasticsearchConverter elasticsearchConverter,
RestHighLevelClient elasticsearchClient) {
return super.elasticsearchOperations(elasticsearchConverter, elasticsearchClient);
}
@Override
protected FieldNamingStrategy fieldNamingStrategy() {
return new SnakeCaseFieldNamingStrategy();
}
}
}

5
src/test/java/org/springframework/data/elasticsearch/core/paginating/SearchAfterIntegrationTests.java
View File

@ -34,17 +34,14 @@ import org.springframework.data.elasticsearch.annotations.FieldType;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class SearchAfterIntegrationTests {
public abstract class SearchAfterIntegrationTests {
@Autowired private ElasticsearchOperations operations;

6
src/test/java/org/springframework/data/elasticsearch/core/paginating/SearchAfterTransportIntegrationTests.java → src/test/java/org/springframework/data/elasticsearch/core/paginating/SearchAfterRestTemplateIntegrationTests.java
View File

@ -15,11 +15,11 @@
*/
package org.springframework.data.elasticsearch.core.paginating;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
public class SearchAfterTransportIntegrationTests extends SearchAfterIntegrationTests {}
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class SearchAfterRestTemplateIntegrationTests extends SearchAfterIntegrationTests {}

17
src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryIntegrationTests.java
View File

@ -28,9 +28,6 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.annotation.Version;
import org.springframework.data.elasticsearch.annotations.Document;
@ -39,11 +36,9 @@ import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.utils.IndexNameProvider;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Rizwan Idrees
@ -52,17 +47,7 @@ import org.springframework.test.context.ContextConfiguration;
* @author James Bodkin
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { CriteriaQueryIntegrationTests.Config.class })
public class CriteriaQueryIntegrationTests {
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {
@Bean
IndexNameProvider indexNameProvider() {
return new IndexNameProvider();
}
}
public abstract class CriteriaQueryIntegrationTests {
@Autowired private ElasticsearchOperations operations;
@Autowired private IndexNameProvider indexNameProvider;

14
src/test/java/org/springframework/data/elasticsearch/core/RuntimeFieldsTransportTemplateIntegrationTests.java → src/test/java/org/springframework/data/elasticsearch/core/query/CriteriaQueryRestTemplateIntegrationTests.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2021 the original author or authors.
* Copyright 2019-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@ -13,27 +13,27 @@
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.core;
package org.springframework.data.elasticsearch.core.query;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.utils.IndexNameProvider;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { RuntimeFieldsTransportTemplateIntegrationTests.Config.class })
public class RuntimeFieldsTransportTemplateIntegrationTests extends RuntimeFieldsIntegrationTests {
@ContextConfiguration(classes = { CriteriaQueryRestTemplateIntegrationTests.Config.class })
public class CriteriaQueryRestTemplateIntegrationTests extends CriteriaQueryIntegrationTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {
@Bean
IndexNameProvider indexNameProvider() {
return new IndexNameProvider("runtime-fields-transport-template");
return new IndexNameProvider();
}
}

2
src/test/java/org/springframework/data/elasticsearch/core/routing/ReactiveElasticsearchOperationsRoutingTests.java
View File

@ -59,7 +59,7 @@ public class ReactiveElasticsearchOperationsRoutingTests {
// check that the used id values go to different shards of the index which is configured to have 5 shards.
// Elasticsearch uses the following function:
Function<String, Integer> calcShard = routing -> Math
.floorMod(ElasticsearchOperationsRoutingTests.Murmur3HashFunction.hash(routing), 5);
.floorMod(RoutingIntegrationTests.Murmur3HashFunction.hash(routing), 5);
Integer shard1 = calcShard.apply(ID_1);
Integer shard2 = calcShard.apply(ID_2);

5
src/test/java/org/springframework/data/elasticsearch/core/routing/ElasticsearchOperationsRoutingTests.java → src/test/java/org/springframework/data/elasticsearch/core/routing/RoutingIntegrationTests.java
View File

@ -38,10 +38,8 @@ import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.mapping.SimpleElasticsearchMappingContext;
import org.springframework.data.elasticsearch.core.query.BaseQuery;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
@ -49,8 +47,7 @@ import org.springframework.test.context.ContextConfiguration;
*/
@SuppressWarnings("ConstantConditions")
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class ElasticsearchOperationsRoutingTests {
public abstract class RoutingIntegrationTests {
private static final String INDEX = "routing-test";
private static final String ID_0 = "id0";

6
src/test/java/org/springframework/data/elasticsearch/core/routing/ElasticsearchOperationsRoutingTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/routing/RoutingRestTemplateIntegrationTests.java
View File

@ -15,11 +15,11 @@
*/
package org.springframework.data.elasticsearch.core.routing;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateConfiguration.class })
public class ElasticsearchOperationsRoutingTransportTests extends ElasticsearchOperationsRoutingTests {}
@ContextConfiguration(classes = { ElasticsearchRestTemplateConfiguration.class })
public class RoutingRestTemplateIntegrationTests extends RoutingIntegrationTests {}

15
src/test/java/org/springframework/data/elasticsearch/core/suggest/ElasticsearchTemplateCompletionTests.java → src/test/java/org/springframework/data/elasticsearch/core/suggest/CompletionIntegrationTests.java
View File

@ -27,24 +27,20 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.CompletionField;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.suggest.response.CompletionSuggestion;
import org.springframework.data.elasticsearch.core.suggest.response.Suggest;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.utils.IndexInitializer;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Rizwan Idrees
@ -55,12 +51,7 @@ import org.springframework.test.context.ContextConfiguration;
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchTemplateCompletionTests.Config.class })
public class ElasticsearchTemplateCompletionTests {
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
public abstract class CompletionIntegrationTests {
@Autowired private ElasticsearchOperations operations;

8
src/test/java/org/springframework/data/elasticsearch/core/suggest/ElasticsearchTemplateCompletionTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/suggest/CompletionRestTemplateIntegrationTests.java
View File

@ -17,17 +17,17 @@ package org.springframework.data.elasticsearch.core.suggest;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateCompletionTransportTests.Config.class })
public class ElasticsearchTemplateCompletionTransportTests extends ElasticsearchTemplateCompletionTests {
@ContextConfiguration(classes = { CompletionRestTemplateIntegrationTests.Config.class })
public class CompletionRestTemplateIntegrationTests extends CompletionIntegrationTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchRepositories(considerNestedRepositories = true)
static class Config {}
}

11
src/test/java/org/springframework/data/elasticsearch/core/suggest/ElasticsearchTemplateCompletionWithContextsTests.java → src/test/java/org/springframework/data/elasticsearch/core/suggest/CompletionWithContextsIntegrationTests.java
View File

@ -36,8 +36,6 @@ import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.CompletionContext;
import org.springframework.data.elasticsearch.annotations.CompletionField;
@ -47,23 +45,16 @@ import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.utils.IndexInitializer;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Robert Gruendler
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ElasticsearchTemplateCompletionWithContextsTests.Config.class })
public class ElasticsearchTemplateCompletionWithContextsTests {
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
public abstract class CompletionWithContextsIntegrationTests {
@Autowired private ElasticsearchOperations operations;
private IndexOperations indexOperations;

11
src/test/java/org/springframework/data/elasticsearch/core/suggest/ElasticsearchTemplateCompletionWithContextsTransportTests.java → src/test/java/org/springframework/data/elasticsearch/core/suggest/CompletionWithContextsRestTemplateIntegrationTests.java
View File

@ -17,18 +17,15 @@ package org.springframework.data.elasticsearch.core.suggest;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchTemplateConfiguration;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Peter-Josef Meisch
*/
@ContextConfiguration(classes = { ElasticsearchTemplateCompletionWithContextsTransportTests.Config.class })
public class ElasticsearchTemplateCompletionWithContextsTransportTests
extends ElasticsearchTemplateCompletionWithContextsTests {
@ContextConfiguration(classes = { CompletionWithContextsRestTemplateIntegrationTests.Config.class })
public class CompletionWithContextsRestTemplateIntegrationTests extends CompletionWithContextsIntegrationTests {
@Configuration
@Import({ ElasticsearchTemplateConfiguration.class })
@EnableElasticsearchRepositories(considerNestedRepositories = true)
@Import({ ElasticsearchRestTemplateConfiguration.class })
static class Config {}
}

8
src/test/java/org/springframework/data/elasticsearch/core/suggest/ReactiveElasticsearchTemplateSuggestIntegrationTests.java → src/test/java/org/springframework/data/elasticsearch/core/suggest/SuggestReactiveTemplateIntegrationTests.java
View File

@ -36,11 +36,11 @@ import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.CompletionField;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.ReactiveElasticsearchOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.IndexQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQuery;
import org.springframework.data.elasticsearch.backend.elasticsearch7.query.NativeSearchQueryBuilder;
import org.springframework.data.elasticsearch.core.suggest.response.CompletionSuggestion;
import org.springframework.data.elasticsearch.core.suggest.response.Suggest;
import org.springframework.data.elasticsearch.junit.jupiter.ReactiveElasticsearchRestTemplateConfiguration;
@ -53,7 +53,7 @@ import org.springframework.lang.Nullable;
*/
@SuppressWarnings("SpringJavaAutowiredMembersInspection")
@SpringIntegrationTest
public class ReactiveElasticsearchTemplateSuggestIntegrationTests {
public class SuggestReactiveTemplateIntegrationTests {
@Configuration
@Import({ ReactiveElasticsearchRestTemplateConfiguration.class })
static class Config {
@ -100,7 +100,7 @@ public class ReactiveElasticsearchTemplateSuggestIntegrationTests {
assertThat(suggestion).isNotNull();
assertThat(suggestion).isInstanceOf(CompletionSuggestion.class);
// noinspection unchecked
List<CompletionSuggestion.Entry.Option<ElasticsearchTemplateCompletionTests.AnnotatedCompletionEntity>> options = ((CompletionSuggestion<ElasticsearchTemplateCompletionTests.AnnotatedCompletionEntity>) suggestion)
List<CompletionSuggestion.Entry.Option<CompletionIntegrationTests.AnnotatedCompletionEntity>> options = ((CompletionSuggestion<CompletionIntegrationTests.AnnotatedCompletionEntity>) suggestion)
.getEntries().get(0).getOptions();
assertThat(options).hasSize(2);
assertThat(options.get(0).getText()).isIn("Marchand", "Mohsin");

2
src/test/java/org/springframework/data/elasticsearch/junit/jupiter/ClusterConnection.java
View File

@ -43,7 +43,6 @@ public class ClusterConnection implements ExtensionContext.Store.CloseableResour
private static final String SDE_TESTCONTAINER_IMAGE_NAME = "sde.testcontainers.image-name";
private static final String SDE_TESTCONTAINER_IMAGE_VERSION = "sde.testcontainers.image-version";
private static final int ELASTICSEARCH_DEFAULT_PORT = 9200;
private static final int ELASTICSEARCH_DEFAULT_TRANSPORT_PORT = 9300;
private static final ThreadLocal<ClusterConnectionInfo> clusterConnectionInfoThreadLocal = new ThreadLocal<>();
@ -102,7 +101,6 @@ public class ClusterConnection implements ExtensionContext.Store.CloseableResour
.withIntegrationtestEnvironment(integrationtestEnvironment)
.withHostAndPort(elasticsearchContainer.getHost(),
elasticsearchContainer.getMappedPort(ELASTICSEARCH_DEFAULT_PORT)) //
.withTransportPort(elasticsearchContainer.getMappedPort(ELASTICSEARCH_DEFAULT_TRANSPORT_PORT)) //
.withElasticsearchContainer(elasticsearchContainer) //
.build();
} catch (Exception e) {

18
src/test/java/org/springframework/data/elasticsearch/junit/jupiter/ClusterConnectionInfo.java
View File

@ -33,7 +33,6 @@ public final class ClusterConnectionInfo {
private final boolean useSsl;
private final String host;
private final int httpPort;
private final int transportPort;
private final String clusterName;
@Nullable private final ElasticsearchContainer elasticsearchContainer;
@ -42,12 +41,11 @@ public final class ClusterConnectionInfo {
}
private ClusterConnectionInfo(IntegrationtestEnvironment integrationtestEnvironment, String host, int httpPort,
boolean useSsl, int transportPort, @Nullable ElasticsearchContainer elasticsearchContainer) {
boolean useSsl, @Nullable ElasticsearchContainer elasticsearchContainer) {
this.integrationtestEnvironment = integrationtestEnvironment;
this.host = host;
this.httpPort = httpPort;
this.useSsl = useSsl;
this.transportPort = transportPort;
this.elasticsearchContainer = elasticsearchContainer;
this.clusterName = "docker-cluster";
}
@ -59,7 +57,6 @@ public final class ClusterConnectionInfo {
", useSsl=" + useSsl + //
", host='" + host + '\'' + //
", httpPort=" + httpPort + //
", transportPort=" + transportPort + //
'}'; //
}
@ -71,10 +68,6 @@ public final class ClusterConnectionInfo {
return httpPort;
}
public int getTransportPort() {
return transportPort;
}
public String getClusterName() {
return clusterName;
}
@ -93,7 +86,6 @@ public final class ClusterConnectionInfo {
private boolean useSsl = false;
private String host;
private int httpPort;
private int transportPort;
@Nullable private ElasticsearchContainer elasticsearchContainer;
public Builder withIntegrationtestEnvironment(IntegrationtestEnvironment integrationtestEnvironment) {
@ -115,19 +107,13 @@ public final class ClusterConnectionInfo {
return this;
}
public Builder withTransportPort(int transportPort) {
this.transportPort = transportPort;
return this;
}
public Builder withElasticsearchContainer(ElasticsearchContainer elasticsearchContainer) {
this.elasticsearchContainer = elasticsearchContainer;
return this;
}
public ClusterConnectionInfo build() {
return new ClusterConnectionInfo(integrationtestEnvironment, host, httpPort, useSsl, transportPort,
elasticsearchContainer);
return new ClusterConnectionInfo(integrationtestEnvironment, host, httpPort, useSsl, elasticsearchContainer);
}
}
}

66
src/test/java/org/springframework/data/elasticsearch/junit/jupiter/ElasticsearchTemplateConfiguration.java
View File

@ -1,66 +0,0 @@
/*
* Copyright 2019-2021 the original author or authors.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.data.elasticsearch.junit.jupiter;
import java.net.InetAddress;
import java.net.UnknownHostException;
import org.elasticsearch.client.Client;
import org.elasticsearch.client.transport.TransportClient;
import org.elasticsearch.common.settings.Settings;
import org.elasticsearch.common.transport.TransportAddress;
import org.elasticsearch.transport.client.PreBuiltTransportClient;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.elasticsearch.backend.elasticsearch7.ElasticsearchTemplate;
import org.springframework.data.elasticsearch.config.ElasticsearchConfigurationSupport;
import org.springframework.data.elasticsearch.core.RefreshPolicy;
import org.springframework.data.elasticsearch.core.convert.ElasticsearchConverter;
/**
* Configuration for Spring Data Elasticsearch using {@link ElasticsearchTemplate}.
*
* @author Peter-Josef Meisch
*/
@Configuration
public class ElasticsearchTemplateConfiguration extends ElasticsearchConfigurationSupport {
@Bean
public Client elasticsearchClient(ClusterConnectionInfo clusterConnectionInfo) throws UnknownHostException {
Settings settings = Settings.builder().put("cluster.name", clusterConnectionInfo.getClusterName()).build();
TransportClient client = new PreBuiltTransportClient(settings);
client.addTransportAddress(new TransportAddress(InetAddress.getByName(clusterConnectionInfo.getHost()),
clusterConnectionInfo.getTransportPort()));
return client;
}
@Bean(name = { "elasticsearchOperations", "elasticsearchTemplate" })
public ElasticsearchTemplate elasticsearchTemplate(Client elasticsearchClient,
ElasticsearchConverter elasticsearchConverter) {
ElasticsearchTemplate template = new ElasticsearchTemplate(elasticsearchClient, elasticsearchConverter);
template.setRefreshPolicy(refreshPolicy());
return template;
}
@Override
protected RefreshPolicy refreshPolicy() {
return RefreshPolicy.IMMEDIATE;
}
}

19
src/test/java/org/springframework/data/elasticsearch/repositories/complex/custommethod/autowiring/ComplexCustomMethodRepositoryTests.java → src/test/java/org/springframework/data/elasticsearch/repositories/complex/custommethod/autowiring/ComplexCustomMethodRepositoryIntegrationTests.java
View File

@ -22,20 +22,14 @@ import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Order;
import org.junit.jupiter.api.Test;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.Import;
import org.springframework.data.annotation.Id;
import org.springframework.data.elasticsearch.annotations.Document;
import org.springframework.data.elasticsearch.annotations.Field;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.junit.jupiter.ElasticsearchRestTemplateConfiguration;
import org.springframework.data.elasticsearch.junit.jupiter.SpringIntegrationTest;
import org.springframework.data.elasticsearch.repository.config.EnableElasticsearchRepositories;
import org.springframework.data.elasticsearch.utils.IndexNameProvider;
import org.springframework.lang.Nullable;
import org.springframework.test.context.ContextConfiguration;
/**
* @author Artur Konczak
@ -43,18 +37,7 @@ import org.springframework.test.context.ContextConfiguration;
* @author Peter-Josef Meisch
*/
@SpringIntegrationTest
@ContextConfiguration(classes = { ComplexCustomMethodRepositoryTests.Config.class })
public class ComplexCustomMethodRepositoryTests {
@Configuration
@Import({ ElasticsearchRestTemplateConfiguration.class })
@EnableElasticsearchRepositories(considerNestedRepositories = true)
static class Config {
@Bean
IndexNameProvider indexNameProvider() {
return new IndexNameProvider("complex-custom-method");
}
}
public abstract class ComplexCustomMethodRepositoryIntegrationTests {
@Autowired private ComplexElasticsearchRepository complexRepository;
@Autowired ElasticsearchOperations operations;

Some files were not shown because too many files have changed in this diff Show More