org.springframework.data.elasticsearch.repository.support.SimpleElasticsearchRepository Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of spring-data-elasticsearch Show documentation
Show all versions of spring-data-elasticsearch Show documentation
Spring Data Implementation for Elasticsearch
/*
* Copyright 2013-2023 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.repository.support;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Optional;
import java.util.stream.Collectors;
import org.springframework.data.domain.Page;
import org.springframework.data.domain.PageImpl;
import org.springframework.data.domain.PageRequest;
import org.springframework.data.domain.Pageable;
import org.springframework.data.domain.Sort;
import org.springframework.data.elasticsearch.core.AbstractElasticsearchTemplate;
import org.springframework.data.elasticsearch.core.ElasticsearchOperations;
import org.springframework.data.elasticsearch.core.IndexOperations;
import org.springframework.data.elasticsearch.core.RefreshPolicy;
import org.springframework.data.elasticsearch.core.SearchHit;
import org.springframework.data.elasticsearch.core.SearchHitSupport;
import org.springframework.data.elasticsearch.core.SearchHits;
import org.springframework.data.elasticsearch.core.SearchPage;
import org.springframework.data.elasticsearch.core.mapping.ElasticsearchPersistentEntity;
import org.springframework.data.elasticsearch.core.mapping.IndexCoordinates;
import org.springframework.data.elasticsearch.core.query.BaseQuery;
import org.springframework.data.elasticsearch.core.query.MoreLikeThisQuery;
import org.springframework.data.elasticsearch.core.query.Query;
import org.springframework.data.elasticsearch.repository.ElasticsearchRepository;
import org.springframework.data.util.StreamUtils;
import org.springframework.data.util.Streamable;
import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* Elasticsearch specific repository implementation. Likely to be used as target within
* {@link ElasticsearchRepositoryFactory}
*
* @author Rizwan Idrees
* @author Mohsin Husen
* @author Ryan Henszey
* @author Kevin Leturc
* @author Mark Paluch
* @author Christoph Strobl
* @author Michael Wirth
* @author Sascha Woo
* @author Murali Chevuri
* @author Peter-Josef Meisch
* @author Aleksei Arsenev
* @author Jens Schauder
*/
public class SimpleElasticsearchRepository implements ElasticsearchRepository {
protected ElasticsearchOperations operations;
protected IndexOperations indexOperations;
protected Class entityClass;
protected ElasticsearchEntityInformation entityInformation;
public SimpleElasticsearchRepository(ElasticsearchEntityInformation metadata,
ElasticsearchOperations operations) {
this.operations = operations;
Assert.notNull(metadata, "ElasticsearchEntityInformation must not be null!");
this.entityInformation = metadata;
this.entityClass = this.entityInformation.getJavaType();
this.indexOperations = operations.indexOps(this.entityClass);
if (shouldCreateIndexAndMapping() && !indexOperations.exists()) {
indexOperations.createWithMapping();
}
}
private boolean shouldCreateIndexAndMapping() {
final ElasticsearchPersistentEntity entity = operations.getElasticsearchConverter().getMappingContext()
.getRequiredPersistentEntity(entityClass);
return entity.isCreateIndexAndMapping();
}
@Override
public Optional findById(ID id) {
return Optional.ofNullable(
execute(operations -> operations.get(stringIdRepresentation(id), entityClass, getIndexCoordinates())));
}
@Override
public Iterable findAll() {
int itemCount = (int) this.count();
if (itemCount == 0) {
return new PageImpl<>(Collections.emptyList());
}
return this.findAll(PageRequest.of(0, Math.max(1, itemCount)));
}
@SuppressWarnings("unchecked")
@Override
public Page findAll(Pageable pageable) {
Assert.notNull(pageable, "pageable must not be null");
Query query = Query.findAll();
query.setPageable(pageable);
SearchHits searchHits = execute(operations -> operations.search(query, entityClass, getIndexCoordinates()));
SearchPage page = SearchHitSupport.searchPageFor(searchHits, query.getPageable());
// noinspection ConstantConditions
return (Page) SearchHitSupport.unwrapSearchHits(page);
}
@SuppressWarnings("unchecked")
@Override
public Iterable findAll(Sort sort) {
Assert.notNull(sort, "sort must not be null");
int itemCount = (int) this.count();
if (itemCount == 0) {
return new PageImpl<>(Collections.emptyList());
}
Pageable pageable = PageRequest.of(0, itemCount, sort);
Query query = Query.findAll();
query.setPageable(pageable);
List> searchHitList = execute(
operations -> operations.search(query, entityClass, getIndexCoordinates()).getSearchHits());
// noinspection ConstantConditions
return (List) SearchHitSupport.unwrapSearchHits(searchHitList);
}
@Override
public Iterable findAllById(Iterable ids) {
Assert.notNull(ids, "ids can't be null.");
List stringIds = stringIdsRepresentation(ids);
Query query = getIdQuery(stringIds);
if (!stringIds.isEmpty()) {
query.setPageable(PageRequest.of(0, stringIds.size()));
}
List> searchHitList = execute(
operations -> operations.search(query, entityClass, getIndexCoordinates()).getSearchHits());
// noinspection ConstantConditions
return (List) SearchHitSupport.unwrapSearchHits(searchHitList);
}
@Override
public long count() {
Query query = Query.findAll();
((BaseQuery) query).setMaxResults(0);
return execute(operations -> operations.count(query, entityClass, getIndexCoordinates()));
}
@Override
public S save(S entity) {
Assert.notNull(entity, "Cannot save 'null' entity.");
// noinspection ConstantConditions
return executeAndRefresh(operations -> operations.save(entity, getIndexCoordinates()));
}
public List save(List entities) {
Assert.notNull(entities, "Cannot insert 'null' as a List.");
return Streamable.of(saveAll(entities)).stream().collect(Collectors.toList());
}
@Override
public Iterable saveAll(Iterable entities) {
Assert.notNull(entities, "Cannot insert 'null' as a List.");
IndexCoordinates indexCoordinates = getIndexCoordinates();
executeAndRefresh(operations -> operations.save(entities, indexCoordinates));
return entities;
}
@Override
public boolean existsById(ID id) {
// noinspection ConstantConditions
return execute(operations -> operations.exists(stringIdRepresentation(id), getIndexCoordinates()));
}
@SuppressWarnings("unchecked")
@Override
public Page searchSimilar(T entity, @Nullable String[] fields, Pageable pageable) {
Assert.notNull(entity, "Cannot search similar records for 'null'.");
Assert.notNull(pageable, "'pageable' cannot be 'null'");
MoreLikeThisQuery query = new MoreLikeThisQuery();
query.setId(stringIdRepresentation(extractIdFromBean(entity)));
query.setPageable(pageable);
if (fields != null) {
query.addFields(fields);
}
SearchHits searchHits = execute(operations -> operations.search(query, entityClass, getIndexCoordinates()));
SearchPage searchPage = SearchHitSupport.searchPageFor(searchHits, pageable);
return (Page) SearchHitSupport.unwrapSearchHits(searchPage);
}
@Override
public void deleteById(ID id) {
Assert.notNull(id, "Cannot delete entity with id 'null'.");
doDelete(id, getIndexCoordinates());
}
@Override
public void delete(T entity) {
Assert.notNull(entity, "Cannot delete 'null' entity.");
doDelete(extractIdFromBean(entity), getIndexCoordinates());
}
@Override
public void deleteAllById(Iterable ids) {
Assert.notNull(ids, "Cannot delete 'null' list.");
List idStrings = new ArrayList<>();
for (ID id : ids) {
idStrings.add(stringIdRepresentation(id));
}
if (idStrings.isEmpty()) {
return;
}
Query query = operations.idsQuery(idStrings);
executeAndRefresh((OperationsCallback) operations -> {
operations.delete(query, entityClass, getIndexCoordinates());
return null;
});
}
@Override
public void deleteAll(Iterable entities) {
Assert.notNull(entities, "Cannot delete 'null' list.");
List ids = new ArrayList<>();
for (T entity : entities) {
ID id = extractIdFromBean(entity);
if (id != null) {
ids.add(id);
}
}
deleteAllById(ids);
}
private void doDelete(@Nullable ID id, IndexCoordinates indexCoordinates) {
if (id != null) {
executeAndRefresh(operations -> operations.delete(stringIdRepresentation(id), indexCoordinates));
}
}
@Override
public void deleteAll() {
IndexCoordinates indexCoordinates = getIndexCoordinates();
executeAndRefresh((OperationsCallback) operations -> {
operations.delete(Query.findAll(), entityClass, indexCoordinates);
return null;
});
}
private void doRefresh() {
RefreshPolicy refreshPolicy = null;
if (operations instanceof AbstractElasticsearchTemplate) {
refreshPolicy = ((AbstractElasticsearchTemplate) operations).getRefreshPolicy();
}
if (refreshPolicy == null) {
indexOperations.refresh();
}
}
// region helper functions
@Nullable
protected ID extractIdFromBean(T entity) {
return entityInformation.getId(entity);
}
private List stringIdsRepresentation(Iterable ids) {
Assert.notNull(ids, "ids can't be null.");
return StreamUtils.createStreamFromIterator(ids.iterator()).map(this::stringIdRepresentation)
.collect(Collectors.toList());
}
protected @Nullable String stringIdRepresentation(@Nullable ID id) {
return operations.convertId(id);
}
private IndexCoordinates getIndexCoordinates() {
return operations.getIndexCoordinatesFor(entityClass);
}
private Query getIdQuery(List stringIds) {
return operations.idsQuery(stringIds);
}
// endregion
// region operations callback
@FunctionalInterface
public interface OperationsCallback {
@Nullable
R doWithOperations(ElasticsearchOperations operations);
}
@Nullable
public R execute(OperationsCallback callback) {
return callback.doWithOperations(operations);
}
@Nullable
public R executeAndRefresh(OperationsCallback callback) {
R result = callback.doWithOperations(operations);
doRefresh();
return result;
}
// endregion
}