From e3238593ce2b71e1a2867d5b9e7aa9df68d38fa3 Mon Sep 17 00:00:00 2001 From: Oliver Gierke Date: Wed, 3 May 2017 12:12:57 +0200 Subject: [PATCH] DATAMONGO-1679 - Adapt to API changes in repository interfaces. --- .../mongodb/core/convert/QueryMapper.java | 2 +- .../data/mongodb/core/query/Field.java | 59 +--- .../data/mongodb/core/query/Query.java | 39 +-- .../mongodb/repository/MongoRepository.java | 10 +- .../repository/ReactiveMongoRepository.java | 32 +- .../query/MongoEntityInformation.java | 6 +- .../MappingMongoEntityInformation.java | 4 +- .../MongoEntityInformationSupport.java | 5 +- .../support/MongoRepositoryFactory.java | 23 +- .../PersistableMongoEntityInformation.java | 3 +- .../support/QueryDslMongoRepository.java | 56 +++- .../ReactiveMongoRepositoryFactory.java | 17 +- .../support/SimpleMongoRepository.java | 152 ++++----- .../SimpleReactiveMongoRepository.java | 308 ++++++++++-------- .../data/mongodb/core/NoExplicitIdTests.java | 3 +- .../mongodb/performance/PerformanceTests.java | 81 ++--- .../performance/ReactivePerformanceTests.java | 75 ++--- ...tractPersonRepositoryIntegrationTests.java | 30 +- .../ComplexIdRepositoryIntegrationTests.java | 5 +- .../ContactRepositoryIntegrationTests.java | 2 +- ...onvertingReactiveMongoRepositoryTests.java | 13 +- ...oRepositoryTextSearchIntegrationTests.java | 31 +- ...RepositoryLazyLoadingIntegrationTests.java | 6 +- .../ReactiveMongoRepositoryTests.java | 2 +- .../SimpleReactiveMongoRepositoryTests.java | 52 +-- .../cdi/CdiExtensionIntegrationTests.java | 2 +- .../repository/cdi/CdiPersonRepository.java | 2 +- .../query/StubParameterAccessor.java | 3 +- ...eryDslMongoRepositoryIntegrationTests.java | 5 +- .../support/SimpleMongoRepositoryTests.java | 12 +- 30 files changed, 459 insertions(+), 581 deletions(-) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/QueryMapper.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/QueryMapper.java index a66ed7487..71a45319f 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/QueryMapper.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/QueryMapper.java @@ -422,7 +422,7 @@ public class QueryMapper { return getMappedObject((BasicDBObject) source, entity); } - if(source instanceof BsonValue) { + if (source instanceof BsonValue) { return source; } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Field.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Field.java index 6d6eaddf1..9db0d0ff4 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Field.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Field.java @@ -15,13 +15,14 @@ */ package org.springframework.data.mongodb.core.query; +import lombok.EqualsAndHashCode; + import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; import org.bson.Document; import org.springframework.util.Assert; -import org.springframework.util.ObjectUtils; /** * @author Thomas Risberg @@ -30,6 +31,7 @@ import org.springframework.util.ObjectUtils; * @author Christoph Strobl * @author Mark Paluch */ +@EqualsAndHashCode public class Field { private final Map criteria = new HashMap(); @@ -83,6 +85,7 @@ public class Field { public Document getFieldsObject() { + @SuppressWarnings({ "unchecked", "rawtypes" }) Document document = new Document((Map) criteria); for (Entry entry : slices.entrySet()) { @@ -99,58 +102,4 @@ public class Field { return document; } - - /* - * (non-Javadoc) - * @see java.lang.Object#equals(java.lang.Object) - */ - @Override - public boolean equals(Object object) { - - if (this == object) { - return true; - } - - if (!(object instanceof Field)) { - return false; - } - - Field that = (Field) object; - - if (!this.criteria.equals(that.criteria)) { - return false; - } - - if (!this.slices.equals(that.slices)) { - return false; - } - - if (!this.elemMatchs.equals(that.elemMatchs)) { - return false; - } - - boolean samePositionKey = this.postionKey == null ? that.postionKey == null - : this.postionKey.equals(that.postionKey); - boolean samePositionValue = this.positionValue == that.positionValue; - - return samePositionKey && samePositionValue; - } - - /* - * (non-Javadoc) - * @see java.lang.Object#hashCode() - */ - @Override - public int hashCode() { - - int result = 17; - - result += 31 * ObjectUtils.nullSafeHashCode(this.criteria); - result += 31 * ObjectUtils.nullSafeHashCode(this.elemMatchs); - result += 31 * ObjectUtils.nullSafeHashCode(this.slices); - result += 31 * ObjectUtils.nullSafeHashCode(this.postionKey); - result += 31 * ObjectUtils.nullSafeHashCode(this.positionValue); - - return result; - } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Query.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Query.java index 18828095a..bf6447a72 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Query.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Query.java @@ -33,7 +33,6 @@ import org.springframework.data.domain.Sort; import org.springframework.data.domain.Sort.Order; import org.springframework.data.mongodb.InvalidMongoDbApiUsageException; import org.springframework.util.Assert; -import org.springframework.util.ObjectUtils; /** * @author Thomas Risberg @@ -48,8 +47,8 @@ public class Query { private final Set> restrictedTypes = new HashSet>(); private final Map criteria = new LinkedHashMap(); - private Field fieldSpec; - private Sort sort; + private Field fieldSpec = null; + private Sort sort = Sort.unsorted(); private long skip; private int limit; private String hint; @@ -103,9 +102,11 @@ public class Query { } public Field fields() { - if (fieldSpec == null) { + + if (this.fieldSpec == null) { this.fieldSpec = new Field(); } + return this.fieldSpec; } @@ -170,22 +171,19 @@ public class Query { */ public Query with(Sort sort) { - if (sort == null || ObjectUtils.nullSafeEquals(Sort.unsorted(), sort)) { + Assert.notNull(sort, "Sort must not be null!"); + + if (sort.isUnsorted()) { return this; } - for (Order order : sort) { - if (order.isIgnoreCase()) { - throw new IllegalArgumentException(String.format("Given sort contained an Order for %s with ignore case! " - + "MongoDB does not support sorting ignoreing case currently!", order.getProperty())); - } - } + sort.stream().filter(Order::isIgnoreCase).findFirst().ifPresent(it -> { - if (this.sort == null) { - this.sort = sort; - } else { - this.sort = this.sort.and(sort); - } + throw new IllegalArgumentException(String.format("Given sort contained an Order for %s with ignore case! " + + "MongoDB does not support sorting ignoring case currently!", it.getProperty())); + }); + + this.sort = this.sort.and(sort); return this; } @@ -238,15 +236,14 @@ public class Query { public Document getSortObject() { - if (this.sort == null) { + if (this.sort.isUnsorted()) { return null; } Document document = new Document(); - for (org.springframework.data.domain.Sort.Order order : this.sort) { - document.put(order.getProperty(), order.isAscending() ? 1 : -1); - } + this.sort.stream()// + .forEach(order -> document.put(order.getProperty(), order.isAscending() ? 1 : -1)); return document; } @@ -440,7 +437,7 @@ public class Query { boolean criteriaEqual = this.criteria.equals(that.criteria); boolean fieldsEqual = nullSafeEquals(this.fieldSpec, that.fieldSpec); - boolean sortEqual = nullSafeEquals(this.sort, that.sort); + boolean sortEqual = this.sort.equals(that.sort); boolean hintEqual = nullSafeEquals(this.hint, that.hint); boolean skipEqual = this.skip == that.skip; boolean limitEqual = this.limit == that.limit; diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/MongoRepository.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/MongoRepository.java index 35b3e6e31..8c5a37613 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/MongoRepository.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/MongoRepository.java @@ -38,10 +38,10 @@ public interface MongoRepository /* * (non-Javadoc) - * @see org.springframework.data.repository.CrudRepository#save(java.lang.Iterable) + * @see org.springframework.data.repository.CrudRepository#saveAll(java.lang.Iterable) */ @Override - List save(Iterable entites); + List saveAll(Iterable entites); /* * (non-Javadoc) @@ -58,9 +58,9 @@ public interface MongoRepository List findAll(Sort sort); /** - * Inserts the given entity. Assumes the instance to be new to be able to apply insertion optimizations. Use - * the returned instance for further operations as the save operation might have changed the entity instance - * completely. Prefer using {@link #save(Object)} instead to avoid the usage of store-specific API. + * Inserts the given entity. Assumes the instance to be new to be able to apply insertion optimizations. Use the + * returned instance for further operations as the save operation might have changed the entity instance completely. + * Prefer using {@link #save(Object)} instead to avoid the usage of store-specific API. * * @param entity must not be {@literal null}. * @return the saved entity diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/ReactiveMongoRepository.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/ReactiveMongoRepository.java index 2513c8a6a..0dd08c263 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/ReactiveMongoRepository.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/ReactiveMongoRepository.java @@ -15,16 +15,14 @@ */ package org.springframework.data.mongodb.repository; -import java.io.Serializable; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; import org.reactivestreams.Publisher; import org.springframework.data.domain.Example; import org.springframework.data.domain.Sort; import org.springframework.data.repository.NoRepositoryBean; - import org.springframework.data.repository.reactive.ReactiveSortingRepository; -import reactor.core.publisher.Flux; -import reactor.core.publisher.Mono; /** * Mongo specific {@link org.springframework.data.repository.Repository} interface with reactive support. @@ -33,12 +31,12 @@ import reactor.core.publisher.Mono; * @since 2.0 */ @NoRepositoryBean -public interface ReactiveMongoRepository extends ReactiveSortingRepository { +public interface ReactiveMongoRepository extends ReactiveSortingRepository { /** - * Inserts the given entity. Assumes the instance to be new to be able to apply insertion optimizations. Use - * the returned instance for further operations as the save operation might have changed the entity instance - * completely. Prefer using {@link #save(Object)} instead to avoid the usage of store-specific API. + * Inserts the given entity. Assumes the instance to be new to be able to apply insertion optimizations. Use the + * returned instance for further operations as the save operation might have changed the entity instance completely. + * Prefer using {@link #save(Object)} instead to avoid the usage of store-specific API. * * @param entity must not be {@literal null}. * @return the saved entity @@ -46,9 +44,9 @@ public interface ReactiveMongoRepository extends Rea Mono insert(S entity); /** - * Inserts the given entities. Assumes the instance to be new to be able to apply insertion optimizations. Use - * the returned instance for further operations as the save operation might have changed the entity instance - * completely. Prefer using {@link #save(Object)} instead to avoid the usage of store-specific API. + * Inserts the given entities. Assumes the instance to be new to be able to apply insertion optimizations. Use the + * returned instance for further operations as the save operation might have changed the entity instance completely. + * Prefer using {@link #save(Object)} instead to avoid the usage of store-specific API. * * @param entities must not be {@literal null}. * @return the saved entity @@ -56,21 +54,23 @@ public interface ReactiveMongoRepository extends Rea Flux insert(Iterable entities); /** - * Inserts the given entities. Assumes the instance to be new to be able to apply insertion optimizations. Use - * the returned instance for further operations as the save operation might have changed the entity instance - * completely. Prefer using {@link #save(Object)} instead to avoid the usage of store-specific API. + * Inserts the given entities. Assumes the instance to be new to be able to apply insertion optimizations. Use the + * returned instance for further operations as the save operation might have changed the entity instance completely. + * Prefer using {@link #save(Object)} instead to avoid the usage of store-specific API. * * @param entities must not be {@literal null}. * @return the saved entity */ Flux insert(Publisher entities); - /* (non-Javadoc) + /* + * (non-Javadoc) * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example) */ Flux findAll(Example example); - /* (non-Javadoc) + /* + * (non-Javadoc) * @see org.springframework.data.repository.query.QueryByExampleExecutor#findAll(org.springframework.data.domain.Example, org.springframework.data.domain.Sort) */ Flux findAll(Example example, Sort sort); diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoEntityInformation.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoEntityInformation.java index a68896c03..fc6ee8e7c 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoEntityInformation.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoEntityInformation.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.repository.query; -import java.io.Serializable; - import org.springframework.data.repository.core.EntityInformation; /** @@ -24,7 +22,7 @@ import org.springframework.data.repository.core.EntityInformation; * * @author Oliver Gierke */ -public interface MongoEntityInformation extends EntityInformation { +public interface MongoEntityInformation extends EntityInformation { /** * Returns the name of the collection the entity shall be persisted to. @@ -39,4 +37,4 @@ public interface MongoEntityInformation extends Enti * @return */ String getIdAttribute(); -} \ No newline at end of file +} diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MappingMongoEntityInformation.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MappingMongoEntityInformation.java index b141894be..1cef31293 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MappingMongoEntityInformation.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MappingMongoEntityInformation.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.repository.support; -import java.io.Serializable; - import org.bson.types.ObjectId; import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity; import org.springframework.data.mongodb.repository.query.MongoEntityInformation; @@ -30,7 +28,7 @@ import org.springframework.data.repository.core.support.PersistentEntityInformat * @author Oliver Gierke * @author Christoph Strobl */ -public class MappingMongoEntityInformation extends PersistentEntityInformation +public class MappingMongoEntityInformation extends PersistentEntityInformation implements MongoEntityInformation { private final MongoPersistentEntity entityMetadata; diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MongoEntityInformationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MongoEntityInformationSupport.java index ccc37205c..f728084ee 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MongoEntityInformationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MongoEntityInformationSupport.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.repository.support; -import java.io.Serializable; - import org.springframework.data.domain.Persistable; import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity; import org.springframework.data.mongodb.repository.query.MongoEntityInformation; @@ -42,8 +40,7 @@ final class MongoEntityInformationSupport { * @return never {@literal null}. */ @SuppressWarnings("unchecked") - static MongoEntityInformation entityInformationFor( - MongoPersistentEntity entity, Class idType) { + static MongoEntityInformation entityInformationFor(MongoPersistentEntity entity, Class idType) { Assert.notNull(entity, "Entity must not be null!"); diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactory.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactory.java index a986ef302..480f65c25 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactory.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/MongoRepositoryFactory.java @@ -23,7 +23,6 @@ import java.util.Optional; import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.data.mapping.context.MappingContext; -import org.springframework.data.mapping.model.MappingException; import org.springframework.data.mongodb.core.MongoOperations; import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity; import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty; @@ -45,7 +44,6 @@ import org.springframework.data.repository.query.RepositoryQuery; import org.springframework.data.repository.reactive.ReactiveCrudRepository; import org.springframework.data.repository.reactive.RxJava1CrudRepository; import org.springframework.data.repository.util.QueryExecutionConverters; -import org.springframework.data.repository.util.ReactiveWrappers; import org.springframework.expression.spel.standard.SpelExpressionParser; import org.springframework.util.Assert; import org.springframework.util.ClassUtils; @@ -91,18 +89,19 @@ public class MongoRepositoryFactory extends RepositoryFactorySupport { @Override protected Class getRepositoryBaseClass(RepositoryMetadata metadata) { - - - boolean isReactiveRepository = (PROJECT_REACTOR_PRESENT && ReactiveCrudRepository.class.isAssignableFrom(metadata.getRepositoryInterface())) || ( - RXJAVA_OBSERVABLE_PRESENT && RxJava1CrudRepository.class.isAssignableFrom(metadata.getRepositoryInterface())); + boolean isReactiveRepository = (PROJECT_REACTOR_PRESENT + && ReactiveCrudRepository.class.isAssignableFrom(metadata.getRepositoryInterface())) + || (RXJAVA_OBSERVABLE_PRESENT + && RxJava1CrudRepository.class.isAssignableFrom(metadata.getRepositoryInterface())); boolean isQueryDslRepository = QUERY_DSL_PRESENT && QuerydslPredicateExecutor.class.isAssignableFrom(metadata.getRepositoryInterface()); if (isReactiveRepository) { - if(isQueryDslRepository) { - throw new InvalidDataAccessApiUsageException("Cannot combine Querydsl and reactive repository in one interface"); + if (isQueryDslRepository) { + throw new InvalidDataAccessApiUsageException( + "Cannot combine Querydsl and reactive repository in one interface"); } return SimpleReactiveMongoRepository.class; } @@ -127,7 +126,8 @@ public class MongoRepositoryFactory extends RepositoryFactorySupport { * @see org.springframework.data.repository.core.support.RepositoryFactorySupport#getQueryLookupStrategy(org.springframework.data.repository.query.QueryLookupStrategy.Key, org.springframework.data.repository.query.EvaluationContextProvider) */ @Override - protected Optional getQueryLookupStrategy(Key key, EvaluationContextProvider evaluationContextProvider) { + protected Optional getQueryLookupStrategy(Key key, + EvaluationContextProvider evaluationContextProvider) { return Optional.of(new MongoQueryLookupStrategy(operations, evaluationContextProvider, mappingContext)); } @@ -135,12 +135,11 @@ public class MongoRepositoryFactory extends RepositoryFactorySupport { * (non-Javadoc) * @see org.springframework.data.repository.core.support.RepositoryFactorySupport#getEntityInformation(java.lang.Class) */ - public MongoEntityInformation getEntityInformation(Class domainClass) { + public MongoEntityInformation getEntityInformation(Class domainClass) { return getEntityInformation(domainClass, null); } - @SuppressWarnings("unchecked") - private MongoEntityInformation getEntityInformation(Class domainClass, + private MongoEntityInformation getEntityInformation(Class domainClass, RepositoryInformation information) { MongoPersistentEntity entity = mappingContext.getRequiredPersistentEntity(domainClass); diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/PersistableMongoEntityInformation.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/PersistableMongoEntityInformation.java index 21a8e8adc..97151cbee 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/PersistableMongoEntityInformation.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/PersistableMongoEntityInformation.java @@ -18,7 +18,6 @@ package org.springframework.data.mongodb.repository.support; import lombok.NonNull; import lombok.RequiredArgsConstructor; -import java.io.Serializable; import java.util.Optional; import org.springframework.data.domain.Persistable; @@ -34,7 +33,7 @@ import org.springframework.data.mongodb.repository.query.MongoEntityInformation; * @since 1.10 */ @RequiredArgsConstructor -class PersistableMongoEntityInformation implements MongoEntityInformation { +class PersistableMongoEntityInformation implements MongoEntityInformation { private final @NonNull MongoEntityInformation delegate; diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/QueryDslMongoRepository.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/QueryDslMongoRepository.java index 984a0c9ef..1cc997ecc 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/QueryDslMongoRepository.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/QueryDslMongoRepository.java @@ -90,10 +90,13 @@ public class QueryDslMongoRepository extends SimpleM /* * (non-Javadoc) - * @see org.springframework.data.querydsl.QueryDslPredicateExecutor#findOne(com.mysema.query.types.Predicate) + * @see org.springframework.data.querydsl.QuerydslPredicateExecutor#findById(com.querydsl.core.types.Predicate) */ @Override public T findOne(Predicate predicate) { + + Assert.notNull(predicate, "Predicate must not be null!"); + return createQueryFor(predicate).fetchOne(); } @@ -103,8 +106,10 @@ public class QueryDslMongoRepository extends SimpleM */ @Override public List findAll(Predicate predicate) { - List list = createQueryFor(predicate).fetchResults().getResults(); - return list; + + Assert.notNull(predicate, "Predicate must not be null!"); + + return createQueryFor(predicate).fetchResults().getResults(); } /* @@ -113,6 +118,10 @@ public class QueryDslMongoRepository extends SimpleM */ @Override public List findAll(Predicate predicate, OrderSpecifier... orders) { + + Assert.notNull(predicate, "Predicate must not be null!"); + Assert.notNull(orders, "Order specifiers must not be null!"); + return createQueryFor(predicate).orderBy(orders).fetchResults().getResults(); } @@ -122,6 +131,10 @@ public class QueryDslMongoRepository extends SimpleM */ @Override public List findAll(Predicate predicate, Sort sort) { + + Assert.notNull(predicate, "Predicate must not be null!"); + Assert.notNull(sort, "Sort must not be null!"); + return applySorting(createQueryFor(predicate), sort).fetchResults().getResults(); } @@ -131,6 +144,9 @@ public class QueryDslMongoRepository extends SimpleM */ @Override public Iterable findAll(OrderSpecifier... orders) { + + Assert.notNull(orders, "Order specifiers must not be null!"); + return createQuery().orderBy(orders).fetchResults().getResults(); } @@ -139,11 +155,15 @@ public class QueryDslMongoRepository extends SimpleM * @see org.springframework.data.querydsl.QueryDslPredicateExecutor#findAll(com.mysema.query.types.Predicate, org.springframework.data.domain.Pageable) */ @Override - public Page findAll(final Predicate predicate, Pageable pageable) { + public Page findAll(Predicate predicate, Pageable pageable) { + + Assert.notNull(predicate, "Predicate must not be null!"); + Assert.notNull(pageable, "Pageable must not be null!"); AbstractMongodbQuery> query = createQueryFor(predicate); - return PageableExecutionUtils.getPage(applyPagination(query, pageable).fetchResults().getResults(), pageable, () -> createQueryFor(predicate).fetchCount()); + return PageableExecutionUtils.getPage(applyPagination(query, pageable).fetchResults().getResults(), pageable, + () -> createQueryFor(predicate).fetchCount()); } /* @@ -153,9 +173,12 @@ public class QueryDslMongoRepository extends SimpleM @Override public Page findAll(Pageable pageable) { + Assert.notNull(pageable, "Pageable must not be null!"); + AbstractMongodbQuery> query = createQuery(); - return PageableExecutionUtils.getPage(applyPagination(query, pageable).fetchResults().getResults(), pageable, () -> createQuery().fetchCount()); + return PageableExecutionUtils.getPage(applyPagination(query, pageable).fetchResults().getResults(), pageable, + () -> createQuery().fetchCount()); } /* @@ -164,6 +187,9 @@ public class QueryDslMongoRepository extends SimpleM */ @Override public List findAll(Sort sort) { + + Assert.notNull(sort, "Sort must not be null!"); + return applySorting(createQuery(), sort).fetchResults().getResults(); } @@ -173,6 +199,9 @@ public class QueryDslMongoRepository extends SimpleM */ @Override public long count(Predicate predicate) { + + Assert.notNull(predicate, "Predicate must not be null!"); + return createQueryFor(predicate).fetchCount(); } @@ -182,6 +211,9 @@ public class QueryDslMongoRepository extends SimpleM */ @Override public boolean exists(Predicate predicate) { + + Assert.notNull(predicate, "Predicate must not be null!"); + return createQueryFor(predicate).fetchCount() > 0; } @@ -214,10 +246,6 @@ public class QueryDslMongoRepository extends SimpleM private AbstractMongodbQuery> applyPagination( AbstractMongodbQuery> query, Pageable pageable) { - if (pageable == null) { - return query; - } - query = query.offset(pageable.getOffset()).limit(pageable.getPageSize()); return applySorting(query, pageable.getSort()); } @@ -232,10 +260,6 @@ public class QueryDslMongoRepository extends SimpleM private AbstractMongodbQuery> applySorting( AbstractMongodbQuery> query, Sort sort) { - if (sort == null) { - return query; - } - // TODO: find better solution than instanceof check if (sort instanceof QSort) { @@ -245,9 +269,7 @@ public class QueryDslMongoRepository extends SimpleM return query; } - for (Order order : sort) { - query.orderBy(toOrder(order)); - } + sort.stream().map(this::toOrder).forEach(it -> query.orderBy(it)); return query; } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/ReactiveMongoRepositoryFactory.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/ReactiveMongoRepositoryFactory.java index 5fc227afa..bcd4c2bbe 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/ReactiveMongoRepositoryFactory.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/ReactiveMongoRepositoryFactory.java @@ -23,7 +23,6 @@ import java.lang.reflect.Method; import java.util.Optional; import org.springframework.data.mapping.context.MappingContext; -import org.springframework.data.mapping.model.MappingException; import org.springframework.data.mongodb.core.ReactiveMongoOperations; import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity; import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty; @@ -98,7 +97,8 @@ public class ReactiveMongoRepositoryFactory extends ReactiveRepositoryFactorySup * @see org.springframework.data.repository.core.support.RepositoryFactorySupport#getQueryLookupStrategy(org.springframework.data.repository.query.QueryLookupStrategy.Key, org.springframework.data.repository.query.EvaluationContextProvider) */ @Override - protected Optional getQueryLookupStrategy(Key key, EvaluationContextProvider evaluationContextProvider) { + protected Optional getQueryLookupStrategy(Key key, + EvaluationContextProvider evaluationContextProvider) { return Optional.of(new MongoQueryLookupStrategy(operations, evaluationContextProvider, mappingContext)); } @@ -106,22 +106,17 @@ public class ReactiveMongoRepositoryFactory extends ReactiveRepositoryFactorySup * (non-Javadoc) * @see org.springframework.data.repository.core.support.RepositoryFactorySupport#getEntityInformation(java.lang.Class) */ - public MongoEntityInformation getEntityInformation(Class domainClass) { + public MongoEntityInformation getEntityInformation(Class domainClass) { return getEntityInformation(domainClass, null); } @SuppressWarnings("unchecked") - private MongoEntityInformation getEntityInformation(Class domainClass, + private MongoEntityInformation getEntityInformation(Class domainClass, RepositoryInformation information) { - Optional> entity = mappingContext.getPersistentEntity(domainClass); + MongoPersistentEntity entity = mappingContext.getRequiredPersistentEntity(domainClass); - if (!entity.isPresent()) { - throw new MappingException( - String.format("Could not lookup mapping metadata for domain class %s!", domainClass.getName())); - } - - return new MappingMongoEntityInformation((MongoPersistentEntity) entity.get(), + return new MappingMongoEntityInformation((MongoPersistentEntity) entity, information != null ? (Class) information.getIdType() : null); } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleMongoRepository.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleMongoRepository.java index e74fc719b..18d06b027 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleMongoRepository.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleMongoRepository.java @@ -18,13 +18,10 @@ package org.springframework.data.mongodb.repository.support; import static org.springframework.data.mongodb.core.query.Criteria.*; import java.io.Serializable; -import java.util.ArrayList; -import java.util.Collection; import java.util.Collections; -import java.util.HashSet; import java.util.List; import java.util.Optional; -import java.util.Set; +import java.util.stream.Collectors; import org.springframework.data.domain.Example; import org.springframework.data.domain.Page; @@ -38,6 +35,8 @@ import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.mongodb.repository.MongoRepository; import org.springframework.data.mongodb.repository.query.MongoEntityInformation; import org.springframework.data.repository.support.PageableExecutionUtils; +import org.springframework.data.util.StreamUtils; +import org.springframework.data.util.Streamable; import org.springframework.util.Assert; /** @@ -72,6 +71,7 @@ public class SimpleMongoRepository implements MongoR * (non-Javadoc) * @see org.springframework.data.repository.CrudRepository#save(java.lang.Object) */ + @Override public S save(S entity) { Assert.notNull(entity, "Entity must not be null!"); @@ -87,57 +87,49 @@ public class SimpleMongoRepository implements MongoR /* * (non-Javadoc) - * @see org.springframework.data.repository.CrudRepository#save(java.lang.Iterable) + * @see org.springframework.data.mongodb.repository.MongoRepository#saveAll(java.lang.Iterable) */ - public List save(Iterable entities) { + @Override + public List saveAll(Iterable entities) { Assert.notNull(entities, "The given Iterable of entities not be null!"); - List result = convertIterableToList(entities); - boolean allNew = true; - - for (S entity : entities) { - if (allNew && !entityInformation.isNew(entity)) { - allNew = false; - } - } + Streamable source = Streamable.of(entities); + boolean allNew = source.stream().allMatch(it -> entityInformation.isNew(it)); if (allNew) { + + List result = source.stream().collect(Collectors.toList()); mongoOperations.insertAll(result); + return result; + } else { - - for (S entity : result) { - save(entity); - } + return source.stream().map(this::save).collect(Collectors.toList()); } - - return result; } /* * (non-Javadoc) * @see org.springframework.data.repository.CrudRepository#findOne(java.io.Serializable) */ - public Optional findOne(ID id) { + @Override + public Optional findById(ID id) { + Assert.notNull(id, "The given id must not be null!"); - return Optional.ofNullable(mongoOperations.findById(id, entityInformation.getJavaType(), entityInformation.getCollectionName())); - } - private Query getIdQuery(Object id) { - return new Query(getIdCriteria(id)); - } - - private Criteria getIdCriteria(Object id) { - return where(entityInformation.getIdAttribute()).is(id); + return Optional.ofNullable( + mongoOperations.findById(id, entityInformation.getJavaType(), entityInformation.getCollectionName())); } /* * (non-Javadoc) - * @see org.springframework.data.repository.CrudRepository#exists(java.io.Serializable) + * @see org.springframework.data.repository.CrudRepository#existsById(java.lang.Object) */ - public boolean exists(ID id) { + @Override + public boolean existsById(ID id) { Assert.notNull(id, "The given id must not be null!"); + return mongoOperations.exists(getIdQuery(id), entityInformation.getJavaType(), entityInformation.getCollectionName()); } @@ -146,16 +138,20 @@ public class SimpleMongoRepository implements MongoR * (non-Javadoc) * @see org.springframework.data.repository.CrudRepository#count() */ + @Override public long count() { return mongoOperations.getCollection(entityInformation.getCollectionName()).count(); } /* * (non-Javadoc) - * @see org.springframework.data.repository.CrudRepository#delete(java.io.Serializable) + * @see org.springframework.data.repository.CrudRepository#deleteById(java.lang.Object) */ - public void delete(ID id) { + @Override + public void deleteById(ID id) { + Assert.notNull(id, "The given id must not be null!"); + mongoOperations.remove(getIdQuery(id), entityInformation.getJavaType(), entityInformation.getCollectionName()); } @@ -163,28 +159,31 @@ public class SimpleMongoRepository implements MongoR * (non-Javadoc) * @see org.springframework.data.repository.CrudRepository#delete(java.lang.Object) */ + @Override public void delete(T entity) { + Assert.notNull(entity, "The given entity must not be null!"); - delete(entityInformation.getId(entity).orElse(null)); + + deleteById(entityInformation.getRequiredId(entity)); } /* * (non-Javadoc) * @see org.springframework.data.repository.CrudRepository#delete(java.lang.Iterable) */ - public void delete(Iterable entities) { + @Override + public void deleteAll(Iterable entities) { Assert.notNull(entities, "The given Iterable of entities not be null!"); - for (T entity : entities) { - delete(entity); - } + entities.forEach(this::delete); } /* * (non-Javadoc) * @see org.springframework.data.repository.CrudRepository#deleteAll() */ + @Override public void deleteAll() { mongoOperations.remove(new Query(), entityInformation.getCollectionName()); } @@ -193,29 +192,30 @@ public class SimpleMongoRepository implements MongoR * (non-Javadoc) * @see org.springframework.data.repository.CrudRepository#findAll() */ + @Override public List findAll() { return findAll(new Query()); } /* * (non-Javadoc) - * @see org.springframework.data.repository.CrudRepository#findAll(java.lang.Iterable) + * @see org.springframework.data.repository.CrudRepository#findAllById(java.lang.Iterable) */ - public Iterable findAll(Iterable ids) { + @Override + public Iterable findAllById(Iterable ids) { - Set parameters = new HashSet(tryDetermineRealSizeOrReturn(ids, 10)); - for (ID id : ids) { - parameters.add(id); - } - - return findAll(new Query(new Criteria(entityInformation.getIdAttribute()).in(parameters))); + return findAll(new Query(new Criteria(entityInformation.getIdAttribute()) + .in(Streamable.of(ids).stream().collect(StreamUtils.toUnmodifiableList())))); } /* * (non-Javadoc) * @see org.springframework.data.repository.PagingAndSortingRepository#findAll(org.springframework.data.domain.Pageable) */ - public Page findAll(final Pageable pageable) { + @Override + public Page findAll(Pageable pageable) { + + Assert.notNull(pageable, "Pageable must not be null!"); Long count = count(); List list = findAll(new Query().with(pageable)); @@ -227,7 +227,11 @@ public class SimpleMongoRepository implements MongoR * (non-Javadoc) * @see org.springframework.data.repository.PagingAndSortingRepository#findAll(org.springframework.data.domain.Sort) */ + @Override public List findAll(Sort sort) { + + Assert.notNull(sort, "Sort must not be null!"); + return findAll(new Query().with(sort)); } @@ -253,7 +257,7 @@ public class SimpleMongoRepository implements MongoR Assert.notNull(entities, "The given Iterable of entities not be null!"); - List list = convertIterableToList(entities); + List list = Streamable.of(entities).stream().collect(StreamUtils.toUnmodifiableList()); if (list.isEmpty()) { return list; @@ -271,13 +275,13 @@ public class SimpleMongoRepository implements MongoR public Page findAll(final Example example, Pageable pageable) { Assert.notNull(example, "Sample must not be null!"); + Assert.notNull(pageable, "Pageable must not be null!"); - final Query q = new Query(new Criteria().alike(example)).with(pageable); - + Query q = new Query(new Criteria().alike(example)).with(pageable); List list = mongoOperations.find(q, example.getProbeType(), entityInformation.getCollectionName()); - return PageableExecutionUtils.getPage(list, pageable, () -> - mongoOperations.count(q, example.getProbeType(), entityInformation.getCollectionName()) - ); + + return PageableExecutionUtils.getPage(list, pageable, + () -> mongoOperations.count(q, example.getProbeType(), entityInformation.getCollectionName())); } /* @@ -288,12 +292,9 @@ public class SimpleMongoRepository implements MongoR public List findAll(Example example, Sort sort) { Assert.notNull(example, "Sample must not be null!"); + Assert.notNull(sort, "Sort must not be null!"); - Query q = new Query(new Criteria().alike(example)); - - if (sort != null) { - q.with(sort); - } + Query q = new Query(new Criteria().alike(example)).with(sort); return mongoOperations.find(q, example.getProbeType(), entityInformation.getCollectionName()); } @@ -304,7 +305,7 @@ public class SimpleMongoRepository implements MongoR */ @Override public List findAll(Example example) { - return findAll(example, (Sort) null); + return findAll(example, Sort.unsorted()); } /* @@ -346,6 +347,14 @@ public class SimpleMongoRepository implements MongoR return mongoOperations.exists(q, example.getProbeType(), entityInformation.getCollectionName()); } + private Query getIdQuery(Object id) { + return new Query(getIdCriteria(id)); + } + + private Criteria getIdCriteria(Object id) { + return where(entityInformation.getIdAttribute()).is(id); + } + private List findAll(Query query) { if (query == null) { @@ -354,29 +363,4 @@ public class SimpleMongoRepository implements MongoR return mongoOperations.find(query, entityInformation.getJavaType(), entityInformation.getCollectionName()); } - - private static List convertIterableToList(Iterable entities) { - - if (entities instanceof List) { - return (List) entities; - } - - int capacity = tryDetermineRealSizeOrReturn(entities, 10); - - if (capacity == 0 || entities == null) { - return Collections. emptyList(); - } - - List list = new ArrayList(capacity); - for (T entity : entities) { - list.add(entity); - } - - return list; - } - - private static int tryDetermineRealSizeOrReturn(Iterable iterable, int defaultSize) { - return iterable == null ? 0 : (iterable instanceof Collection) ? ((Collection) iterable).size() : defaultSize; - } - } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleReactiveMongoRepository.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleReactiveMongoRepository.java index bc3e9b250..b6f1e8678 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleReactiveMongoRepository.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/support/SimpleReactiveMongoRepository.java @@ -17,13 +17,14 @@ package org.springframework.data.mongodb.repository.support; import static org.springframework.data.mongodb.core.query.Criteria.*; +import lombok.NonNull; +import lombok.RequiredArgsConstructor; +import reactor.core.publisher.Flux; +import reactor.core.publisher.Mono; + import java.io.Serializable; -import java.util.ArrayList; -import java.util.Collection; -import java.util.Collections; -import java.util.HashSet; import java.util.List; -import java.util.Set; +import java.util.stream.Collectors; import org.reactivestreams.Publisher; import org.springframework.data.domain.Example; @@ -33,47 +34,41 @@ import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.mongodb.repository.ReactiveMongoRepository; import org.springframework.data.mongodb.repository.query.MongoEntityInformation; +import org.springframework.data.util.StreamUtils; +import org.springframework.data.util.Streamable; import org.springframework.util.Assert; -import reactor.core.publisher.Flux; -import reactor.core.publisher.Mono; - /** * Reactive repository base implementation for Mongo. * * @author Mark Paluch + * @author Oliver Gierke * @since 2.0 */ +@RequiredArgsConstructor public class SimpleReactiveMongoRepository implements ReactiveMongoRepository { - private final ReactiveMongoOperations mongoOperations; - private final MongoEntityInformation entityInformation; + private final @NonNull MongoEntityInformation entityInformation; + private final @NonNull ReactiveMongoOperations mongoOperations; - /** - * Creates a new {@link SimpleReactiveMongoRepository} for the given {@link MongoEntityInformation} and - * {@link ReactiveMongoOperations}. - * - * @param metadata must not be {@literal null}. - * @param mongoOperations must not be {@literal null}. + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#findById(java.lang.Object) */ - public SimpleReactiveMongoRepository(MongoEntityInformation metadata, - ReactiveMongoOperations mongoOperations) { - - Assert.notNull(metadata, "MongoEntityInformation must not be null!"); - Assert.notNull(mongoOperations, "ReactiveMongoOperations must not be null!"); - - this.entityInformation = metadata; - this.mongoOperations = mongoOperations; - } - - public Mono findOne(ID id) { + @Override + public Mono findById(ID id) { Assert.notNull(id, "The given id must not be null!"); return mongoOperations.findById(id, entityInformation.getJavaType(), entityInformation.getCollectionName()); } - public Mono findOne(Mono mono) { + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#findById(reactor.core.publisher.Mono) + */ + @Override + public Mono findById(Mono mono) { Assert.notNull(mono, "The given id must not be null!"); @@ -81,15 +76,12 @@ public class SimpleReactiveMongoRepository implement id -> mongoOperations.findById(id, entityInformation.getJavaType(), entityInformation.getCollectionName())); } - public Mono findOne(Example example) { - - Assert.notNull(example, "Sample must not be null!"); - - Query q = new Query(new Criteria().alike(example)); - return mongoOperations.findOne(q, example.getProbeType(), entityInformation.getCollectionName()); - } - - public Mono exists(ID id) { + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#existsById(java.lang.Object) + */ + @Override + public Mono existsById(ID id) { Assert.notNull(id, "The given id must not be null!"); @@ -97,7 +89,12 @@ public class SimpleReactiveMongoRepository implement entityInformation.getCollectionName()); } - public Mono exists(Mono mono) { + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#existsById(reactor.core.publisher.Mono) + */ + @Override + public Mono existsById(Mono mono) { Assert.notNull(mono, "The given id must not be null!"); @@ -106,76 +103,81 @@ public class SimpleReactiveMongoRepository implement } - public Mono exists(Example example) { - - Assert.notNull(example, "Sample must not be null!"); - - Query q = new Query(new Criteria().alike(example)); - return mongoOperations.exists(q, example.getProbeType(), entityInformation.getCollectionName()); - } - @Override public Flux findAll() { return findAll(new Query()); } + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#findAllById(java.lang.Iterable) + */ @Override - public Flux findAll(Iterable ids) { + public Flux findAllById(Iterable ids) { Assert.notNull(ids, "The given Iterable of Id's must not be null!"); - Set parameters = new HashSet(tryDetermineRealSizeOrReturn(ids, 10)); - for (ID id : ids) { - parameters.add(id); - } - - return findAll(new Query(new Criteria(entityInformation.getIdAttribute()).in(parameters))); + return findAll(new Query(new Criteria(entityInformation.getIdAttribute()) + .in(Streamable.of(ids).stream().collect(StreamUtils.toUnmodifiableList())))); } + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#findAllById(org.reactivestreams.Publisher) + */ @Override - public Flux findAll(Publisher idStream) { + public Flux findAllById(Publisher ids) { - Assert.notNull(idStream, "The given Publisher of Id's must not be null!"); + Assert.notNull(ids, "The given Publisher of Id's must not be null!"); - return Flux.from(idStream).buffer().flatMap(this::findAll); + return Flux.from(ids).buffer().flatMap(this::findAllById); } + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveSortingRepository#findAll(org.springframework.data.domain.Sort) + */ @Override public Flux findAll(Sort sort) { return findAll(new Query().with(sort)); } + /* + * (non-Javadoc) + * @see org.springframework.data.mongodb.repository.ReactiveMongoRepository#findAll(org.springframework.data.domain.Example, org.springframework.data.domain.Sort) + */ @Override public Flux findAll(Example example, Sort sort) { Assert.notNull(example, "Sample must not be null!"); + Assert.notNull(sort, "Sort must not be null!"); - Query q = new Query(new Criteria().alike(example)); + Query query = new Query(new Criteria().alike(example)).with(sort); - if (sort != null) { - q.with(sort); - } - - return mongoOperations.find(q, example.getProbeType(), entityInformation.getCollectionName()); + return mongoOperations.find(query, example.getProbeType(), entityInformation.getCollectionName()); } + /* + * (non-Javadoc) + * @see org.springframework.data.mongodb.repository.ReactiveMongoRepository#findAll(org.springframework.data.domain.Example) + */ @Override public Flux findAll(Example example) { - return findAll(example, null); + return findAll(example, Sort.unsorted()); } + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#count() + */ public Mono count() { return mongoOperations.count(new Query(), entityInformation.getCollectionName()); } - public Mono count(Example example) { - - Assert.notNull(example, "Sample must not be null!"); - - Query q = new Query(new Criteria().alike(example)); - return mongoOperations.count(q, example.getProbeType(), entityInformation.getCollectionName()); - } - + /* + * (non-Javadoc) + * @see org.springframework.data.mongodb.repository.ReactiveMongoRepository#insert(java.lang.Object) + */ @Override public Mono insert(S entity) { @@ -184,20 +186,24 @@ public class SimpleReactiveMongoRepository implement return mongoOperations.insert(entity, entityInformation.getCollectionName()); } + /* + * (non-Javadoc) + * @see org.springframework.data.mongodb.repository.ReactiveMongoRepository#insert(java.lang.Iterable) + */ @Override public Flux insert(Iterable entities) { Assert.notNull(entities, "The given Iterable of entities must not be null!"); - List list = convertIterableToList(entities); + List source = Streamable.of(entities).stream().collect(StreamUtils.toUnmodifiableList()); - if (list.isEmpty()) { - return Flux.empty(); - } - - return Flux.from(mongoOperations.insertAll(list)); + return source.isEmpty() ? Flux.empty() : Flux.from(mongoOperations.insertAll(source)); } + /* + * (non-Javadoc) + * @see org.springframework.data.mongodb.repository.ReactiveMongoRepository#insert(org.reactivestreams.Publisher) + */ @Override public Flux insert(Publisher entities) { @@ -206,6 +212,11 @@ public class SimpleReactiveMongoRepository implement return Flux.from(entities).flatMap(entity -> mongoOperations.insert(entity, entityInformation.getCollectionName())); } + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#save(java.lang.Object) + */ + @Override public Mono save(S entity) { Assert.notNull(entity, "Entity must not be null!"); @@ -217,85 +228,119 @@ public class SimpleReactiveMongoRepository implement return mongoOperations.save(entity, entityInformation.getCollectionName()); } - public Flux save(Iterable entities) { + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#saveAll(java.lang.Iterable) + */ + @Override + public Flux saveAll(Iterable entities) { Assert.notNull(entities, "The given Iterable of entities must not be null!"); - List result = convertIterableToList(entities); - boolean allNew = true; + Streamable source = Streamable.of(entities); - for (S entity : entities) { - if (allNew && !entityInformation.isNew(entity)) { - allNew = false; - } - } - - if (allNew) { - return Flux.from(mongoOperations.insertAll(result)); - } - - List> monos = new ArrayList<>(); - for (S entity : result) { - monos.add(save(entity)); - } - - return Flux.merge(monos); + return source.stream().allMatch(it -> entityInformation.isNew(it)) ? // + mongoOperations.insertAll(source.stream().collect(Collectors.toList())) : // + Flux.fromIterable(entities).flatMap(this::save); } + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#saveAll(org.reactivestreams.Publisher) + */ @Override - public Flux save(Publisher entityStream) { + public Flux saveAll(Publisher entityStream) { Assert.notNull(entityStream, "The given Publisher of entities must not be null!"); - return Flux.from(entityStream).flatMap(entity -> { - - if (entityInformation.isNew(entity)) { - return mongoOperations.insert(entity, entityInformation.getCollectionName()).then(Mono.just(entity)); - } - - return mongoOperations.save(entity, entityInformation.getCollectionName()).then(Mono.just(entity)); - }); + return Flux.from(entityStream) + .flatMap(entity -> entityInformation.isNew(entity) ? // + mongoOperations.insert(entity, entityInformation.getCollectionName()).then(Mono.just(entity)) : // + mongoOperations.save(entity, entityInformation.getCollectionName()).then(Mono.just(entity))); } - // TODO: should this one really be void? - public Mono delete(ID id) { + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#deleteById(java.lang.Object) + */ + @Override + public Mono deleteById(ID id) { Assert.notNull(id, "The given id must not be null!"); return mongoOperations .remove(getIdQuery(id), entityInformation.getJavaType(), entityInformation.getCollectionName()).then(); - } - // TODO: should this one really be void? + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#delete(java.lang.Object) + */ + @Override public Mono delete(T entity) { Assert.notNull(entity, "The given entity must not be null!"); - return delete(entityInformation.getId(entity).get()); + return deleteById(entityInformation.getRequiredId(entity)); } - // TODO: should this one really be void? - public Mono delete(Iterable entities) { + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#deleteAll(java.lang.Iterable) + */ + @Override + public Mono deleteAll(Iterable entities) { Assert.notNull(entities, "The given Iterable of entities must not be null!"); - return Flux.fromIterable(entities).flatMap(entity -> delete(entityInformation.getId(entity).get())).then(); + return Flux.fromIterable(entities).flatMap(entity -> deleteById(entityInformation.getRequiredId(entity))).then(); } - // TODO: should this one really be void? + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#deleteAll(org.reactivestreams.Publisher) + */ @Override - public Mono delete(Publisher entityStream) { + public Mono deleteAll(Publisher entityStream) { Assert.notNull(entityStream, "The given Publisher of entities must not be null!"); - return Flux.from(entityStream).flatMap(entity -> delete(entityInformation.getId(entity).get())).then(); + return Flux.from(entityStream)// + .map(it -> entityInformation.getRequiredId(it))// + .flatMap(this::deleteById)// + .then(); } - // TODO: should this one really be void? + /* + * (non-Javadoc) + * @see org.springframework.data.repository.reactive.ReactiveCrudRepository#deleteAll() + */ public Mono deleteAll() { - return mongoOperations.remove(new Query(), entityInformation.getCollectionName()) - .then(Mono.empty()); + return mongoOperations.remove(new Query(), entityInformation.getCollectionName()).then(Mono.empty()); + } + + public Mono exists(Example example) { + + Assert.notNull(example, "Sample must not be null!"); + + Query q = new Query(new Criteria().alike(example)); + return mongoOperations.exists(q, example.getProbeType(), entityInformation.getCollectionName()); + } + + public Mono findOne(Example example) { + + Assert.notNull(example, "Sample must not be null!"); + + Query q = new Query(new Criteria().alike(example)); + return mongoOperations.findOne(q, example.getProbeType(), entityInformation.getCollectionName()); + } + + public Mono count(Example example) { + + Assert.notNull(example, "Sample must not be null!"); + + Query q = new Query(new Criteria().alike(example)); + return mongoOperations.count(q, example.getProbeType(), entityInformation.getCollectionName()); } private Query getIdQuery(Object id) { @@ -314,29 +359,4 @@ public class SimpleReactiveMongoRepository implement return mongoOperations.find(query, entityInformation.getJavaType(), entityInformation.getCollectionName()); } - - private static List convertIterableToList(Iterable entities) { - - if (entities instanceof List) { - return (List) entities; - } - - int capacity = tryDetermineRealSizeOrReturn(entities, 10); - - if (capacity == 0 || entities == null) { - return Collections.emptyList(); - } - - List list = new ArrayList(capacity); - for (T entity : entities) { - list.add(entity); - } - - return list; - } - - private static int tryDetermineRealSizeOrReturn(Iterable iterable, int defaultSize) { - return iterable == null ? 0 : (iterable instanceof Collection) ? ((Collection) iterable).size() : defaultSize; - } - } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java index cb3f14bc4..9d459bf82 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/NoExplicitIdTests.java @@ -34,7 +34,6 @@ import org.springframework.data.mongodb.repository.config.EnableMongoRepositorie import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import com.mongodb.Mongo; import com.mongodb.MongoClient; /** @@ -107,7 +106,7 @@ public class NoExplicitIdTests { Map map = mongoOps.findOne(query(where("someString").is(noid.someString)), Map.class, "typeWithoutIdProperty"); - Optional retrieved = repo.findOne(map.get("_id").toString()); + Optional retrieved = repo.findById(map.get("_id").toString()); assertThat(retrieved.get().someString, is(noid.someString)); } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/performance/PerformanceTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/performance/PerformanceTests.java index 694130072..d35940c5f 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/performance/PerformanceTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/performance/PerformanceTests.java @@ -31,6 +31,7 @@ import java.util.Map; import java.util.Random; import java.util.Set; import java.util.regex.Pattern; +import java.util.stream.Collectors; import org.bson.Document; import org.bson.types.ObjectId; @@ -44,7 +45,6 @@ import org.springframework.data.mongodb.core.convert.DefaultDbRefResolver; import org.springframework.data.mongodb.core.convert.MappingMongoConverter; import org.springframework.data.mongodb.core.convert.MongoConverter; import org.springframework.data.mongodb.core.mapping.MongoMappingContext; -import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.mongodb.repository.MongoRepository; import org.springframework.data.mongodb.repository.support.MongoRepositoryFactoryBean; import org.springframework.util.Assert; @@ -57,7 +57,6 @@ import com.mongodb.DB; import com.mongodb.DBCollection; import com.mongodb.DBCursor; import com.mongodb.DBObject; -import com.mongodb.Mongo; import com.mongodb.MongoClient; import com.mongodb.WriteConcern; @@ -226,22 +225,13 @@ public class PerformanceTests { } private long queryUsingTemplate() { - executeWatched(new WatchCallback>() { - public List doInWatch() { - Query query = query(where("addresses.zipCode").regex(".*1.*")); - return operations.find(query, Person.class, "template"); - } - }); + executeWatched(() -> operations.find(query(where("addresses.zipCode").regex(".*1.*")), Person.class, "template")); return watch.getLastTaskTimeMillis(); } private long queryUsingRepository() { - executeWatched(new WatchCallback>() { - public List doInWatch() { - return repository.findByAddressesZipCodeContaining("1"); - } - }); + executeWatched(() -> repository.findByAddressesZipCodeContaining("1")); return watch.getLastTaskTimeMillis(); } @@ -288,93 +278,62 @@ public class PerformanceTests { private long writingObjectsUsingPlainDriver(int numberOfPersons) { - final DBCollection collection = mongo.getDB(DATABASE_NAME).getCollection("driver"); - final List persons = getPersonObjects(numberOfPersons); + DBCollection collection = mongo.getDB(DATABASE_NAME).getCollection("driver"); + List persons = getPersonObjects(numberOfPersons); - executeWatched(new WatchCallback() { - public Void doInWatch() { - for (Person person : persons) { - collection.save(new BasicDBObject(person.toDocument())); - } - return null; - } - }); + executeWatched(() -> persons.stream().map(it -> collection.save(new BasicDBObject(it.toDocument())))); return watch.getLastTaskTimeMillis(); } private long writingObjectsUsingRepositories(int numberOfPersons) { - final List persons = getPersonObjects(numberOfPersons); + List persons = getPersonObjects(numberOfPersons); - executeWatched(new WatchCallback() { - public Void doInWatch() { - repository.save(persons); - return null; - } - }); + executeWatched(() -> repository.saveAll(persons)); return watch.getLastTaskTimeMillis(); } private long writingObjectsUsingMongoTemplate(int numberOfPersons) { - final List persons = getPersonObjects(numberOfPersons); + List persons = getPersonObjects(numberOfPersons); - executeWatched(new WatchCallback() { - public Void doInWatch() { - for (Person person : persons) { - operations.save(person, "template"); - } - return null; - } - }); + executeWatched(() -> persons.stream()// + .peek(it -> operations.save(it, "template"))// + .collect(Collectors.toList())); return watch.getLastTaskTimeMillis(); } private long readingUsingPlainDriver() { - executeWatched(new WatchCallback>() { - public List doInWatch() { - return toPersons(mongo.getDB(DATABASE_NAME).getCollection("driver").find()); - } - }); + executeWatched(() -> toPersons(mongo.getDB(DATABASE_NAME).getCollection("driver").find())); return watch.getLastTaskTimeMillis(); } private long readingUsingTemplate() { - executeWatched(new WatchCallback>() { - public List doInWatch() { - return operations.findAll(Person.class, "template"); - } - }); + executeWatched(() -> operations.findAll(Person.class, "template")); return watch.getLastTaskTimeMillis(); } private long readingUsingRepository() { - executeWatched(new WatchCallback>() { - public List doInWatch() { - return repository.findAll(); - } - }); + executeWatched(repository::findAll); return watch.getLastTaskTimeMillis(); } private long queryUsingPlainDriver() { - executeWatched(new WatchCallback>() { - public List doInWatch() { + executeWatched(() -> { - DBCollection collection = mongo.getDB(DATABASE_NAME).getCollection("driver"); + DBCollection collection = mongo.getDB(DATABASE_NAME).getCollection("driver"); - BasicDBObject regex = new BasicDBObject("$regex", Pattern.compile(".*1.*")); - BasicDBObject query = new BasicDBObject("addresses.zipCode", regex); - return toPersons(collection.find(query)); - } + BasicDBObject regex = new BasicDBObject("$regex", Pattern.compile(".*1.*")); + BasicDBObject query = new BasicDBObject("addresses.zipCode", regex); + return toPersons(collection.find(query)); }); return watch.getLastTaskTimeMillis(); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/performance/ReactivePerformanceTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/performance/ReactivePerformanceTests.java index fd440ca17..d428cfe1d 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/performance/ReactivePerformanceTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/performance/ReactivePerformanceTests.java @@ -18,7 +18,6 @@ package org.springframework.data.mongodb.performance; import static org.springframework.data.mongodb.core.query.Criteria.*; import static org.springframework.data.mongodb.core.query.Query.*; -import org.springframework.util.Assert; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @@ -58,6 +57,7 @@ import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty; import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.mongodb.repository.ReactiveMongoRepository; import org.springframework.data.mongodb.repository.support.ReactiveMongoRepositoryFactory; +import org.springframework.util.Assert; import org.springframework.util.StopWatch; import org.springframework.util.StringUtils; @@ -107,8 +107,8 @@ public class ReactivePerformanceTests { converter = new MappingMongoConverter(new DbRefResolver() { @Override - public Optional resolveDbRef(MongoPersistentProperty property, DBRef dbref, DbRefResolverCallback callback, - DbRefProxyHandler proxyHandler) { + public Optional resolveDbRef(MongoPersistentProperty property, DBRef dbref, + DbRefResolverCallback callback, DbRefProxyHandler proxyHandler) { return Optional.empty(); } @@ -307,18 +307,12 @@ public class ReactivePerformanceTests { private long writingObjectsUsingPlainDriver(int numberOfPersons, WriteConcern concern) { - final MongoCollection collection = mongo.getDatabase(DATABASE_NAME).getCollection("driver") + MongoCollection collection = mongo.getDatabase(DATABASE_NAME).getCollection("driver") .withWriteConcern(concern); - final List persons = getPersonObjects(numberOfPersons); + List persons = getPersonObjects(numberOfPersons); - executeWatched(new WatchCallback() { - public Void doInWatch() { - for (Person person : persons) { - Mono.from(collection.insertOne(new Document(person.toDocument()))).block(); - } - return null; - } - }); + executeWatched( + () -> persons.stream().map(it -> Mono.from(collection.insertOne(new Document(it.toDocument()))).block())); return watch.getLastTaskTimeMillis(); } @@ -327,14 +321,7 @@ public class ReactivePerformanceTests { final List persons = getPersonObjects(numberOfPersons); operations.setWriteConcern(concern); - executeWatched(new WatchCallback() { - public Void doInWatch() { - for (Person person : persons) { - repository.save(person).block(); - } - return null; - } - }); + executeWatched(() -> persons.stream().map(it -> repository.save(it).block())); return watch.getLastTaskTimeMillis(); } @@ -343,14 +330,9 @@ public class ReactivePerformanceTests { final List persons = getPersonObjects(numberOfPersons); - executeWatched(new WatchCallback() { - public Void doInWatch() { - operations.setWriteConcern(concern); - for (Person person : persons) { - Mono.from(operations.save(person, "template")).block(); - } - return null; - } + executeWatched(() -> { + operations.setWriteConcern(concern); + return persons.stream().map(it -> operations.save(it, "template").block()); }); return watch.getLastTaskTimeMillis(); @@ -358,47 +340,34 @@ public class ReactivePerformanceTests { private long writingAsyncObjectsUsingPlainDriver(int numberOfPersons, WriteConcern concern) { - final MongoCollection collection = mongo.getDatabase(DATABASE_NAME).getCollection("driver") + MongoCollection collection = mongo.getDatabase(DATABASE_NAME).getCollection("driver") .withWriteConcern(concern); - final List persons = getPersonObjects(numberOfPersons); + List persons = getPersonObjects(numberOfPersons); - executeWatched(new WatchCallback() { - public Void doInWatch() { - - Flux.from(collection + executeWatched(() -> Flux + .from(collection .insertMany(persons.stream().map(person -> new Document(person.toDocument())).collect(Collectors.toList()))) - .then().block(); - return null; - } - }); + .then().block()); return watch.getLastTaskTimeMillis(); } private long writingAsyncObjectsUsingRepositories(int numberOfPersons, WriteConcern concern) { - final List persons = getPersonObjects(numberOfPersons); + List persons = getPersonObjects(numberOfPersons); operations.setWriteConcern(concern); - executeWatched(new WatchCallback() { - public Void doInWatch() { - repository.save(persons).then().block(); - return null; - } - }); + executeWatched(() -> repository.saveAll(persons).then().block()); return watch.getLastTaskTimeMillis(); } private long writingAsyncObjectsUsingMongoTemplate(int numberOfPersons, WriteConcern concern) { - final List persons = getPersonObjects(numberOfPersons); + List persons = getPersonObjects(numberOfPersons); - executeWatched(new WatchCallback() { - public Void doInWatch() { - operations.setWriteConcern(concern); - Flux.from(operations.insertAll(persons)).then().block(); - return null; - } + executeWatched(() -> { + operations.setWriteConcern(concern); + return Flux.from(operations.insertAll(persons)).then().block(); }); return watch.getLastTaskTimeMillis(); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java index 92b257e66..42a64c750 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/AbstractPersonRepositoryIntegrationTests.java @@ -104,13 +104,13 @@ public abstract class AbstractPersonRepositoryIntegrationTests { person = new QPerson("person"); - all = repository.save(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia)); + all = repository.saveAll(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia)); } @Test public void findsPersonById() throws Exception { - assertThat(repository.findOne(dave.getId().toString()), is(Optional.of(dave))); + assertThat(repository.findById(dave.getId().toString()), is(Optional.of(dave))); } @Test @@ -123,7 +123,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { @Test public void findsAllWithGivenIds() { - Iterable result = repository.findAll(Arrays.asList(dave.id, boyd.id)); + Iterable result = repository.findAllById(Arrays.asList(dave.id, boyd.id)); assertThat(result, hasItems(dave, boyd)); assertThat(result, not(hasItems(oliver, carter, stefan, leroi, alicia))); } @@ -142,7 +142,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { @Test public void deletesPersonByIdCorrectly() { - repository.delete(dave.getId().toString()); + repository.deleteById(dave.getId().toString()); List result = repository.findAll(); @@ -377,7 +377,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { @Test // DATADOC-190 public void existsWorksCorrectly() { - assertThat(repository.exists(dave.getId()), is(true)); + assertThat(repository.existsById(dave.getId()), is(true)); } @Test(expected = DuplicateKeyException.class) @@ -602,7 +602,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { boyd.setLocation(here); leroi.setLocation(here); - repository.save(Arrays.asList(dave, oliver, carter, boyd, leroi)); + repository.saveAll(Arrays.asList(dave, oliver, carter, boyd, leroi)); GeoPage results = repository.findByLocationNear(new Point(-73.99, 40.73), new Distance(2000, Metrics.KILOMETERS), PageRequest.of(1, 2)); @@ -624,7 +624,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { oliver.setLocation(point); carter.setLocation(point); - repository.save(Arrays.asList(dave, oliver, carter)); + repository.saveAll(Arrays.asList(dave, oliver, carter)); GeoPage results = repository.findByLocationNear(new Point(-73.99, 40.73), new Distance(2000, Metrics.KILOMETERS), PageRequest.of(1, 2)); @@ -858,7 +858,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { @Test // DATAMONGO-950 public void shouldLimitCollectionQueryToMaxResultsWhenPresent() { - repository.save(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), + repository.saveAll(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), new Person("Bob-3", "Dylan"), new Person("Bob-4", "Dylan"), new Person("Bob-5", "Dylan"))); List result = repository.findTop3ByLastnameStartingWith("Dylan"); assertThat(result.size(), is(3)); @@ -867,7 +867,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { @Test // DATAMONGO-950, DATAMONGO-1464 public void shouldNotLimitPagedQueryWhenPageRequestWithinBounds() { - repository.save(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), + repository.saveAll(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), new Person("Bob-3", "Dylan"), new Person("Bob-4", "Dylan"), new Person("Bob-5", "Dylan"))); Page result = repository.findTop3ByLastnameStartingWith("Dylan", PageRequest.of(0, 2)); assertThat(result.getContent().size(), is(2)); @@ -877,7 +877,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { @Test // DATAMONGO-950 public void shouldLimitPagedQueryWhenPageRequestExceedsUpperBoundary() { - repository.save(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), + repository.saveAll(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), new Person("Bob-3", "Dylan"), new Person("Bob-4", "Dylan"), new Person("Bob-5", "Dylan"))); Page result = repository.findTop3ByLastnameStartingWith("Dylan", PageRequest.of(1, 2)); assertThat(result.getContent().size(), is(1)); @@ -886,7 +886,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { @Test // DATAMONGO-950, DATAMONGO-1464 public void shouldReturnEmptyWhenPageRequestedPageIsTotallyOutOfScopeForLimit() { - repository.save(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), + repository.saveAll(Arrays.asList(new Person("Bob-1", "Dylan"), new Person("Bob-2", "Dylan"), new Person("Bob-3", "Dylan"), new Person("Bob-4", "Dylan"), new Person("Bob-5", "Dylan"))); Page result = repository.findTop3ByLastnameStartingWith("Dylan", PageRequest.of(100, 2)); assertThat(result.getContent().size(), is(0)); @@ -946,7 +946,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { persons.add(new Person(String.format("%03d", i), "ln" + 1, 100)); } - repository.save(persons); + repository.saveAll(persons); Slice slice = repository.findByAgeGreaterThan(50, PageRequest.of(0, 20, Direction.ASC, "firstname")); assertThat(slice, contains(persons.subList(0, 20).toArray())); @@ -985,7 +985,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { persons.add(person); } - repository.save(persons); + repository.saveAll(persons); QPerson person = QPerson.person; @@ -1008,7 +1008,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { persons.add(person); } - repository.save(persons); + repository.saveAll(persons); PageRequest pageRequest = PageRequest.of(0, 2, new QSort(person.address.street.desc())); Iterable result = repository.findAll(pageRequest); @@ -1030,7 +1030,7 @@ public abstract class AbstractPersonRepositoryIntegrationTests { persons.add(person); } - repository.save(persons); + repository.saveAll(persons); Iterable result = repository.findAll(new QSort(person.address.street.desc())); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ComplexIdRepositoryIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ComplexIdRepositoryIntegrationTests.java index 290e8015d..0ce746369 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ComplexIdRepositoryIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ComplexIdRepositoryIntegrationTests.java @@ -35,7 +35,6 @@ import org.springframework.data.mongodb.repository.config.EnableMongoRepositorie import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import com.mongodb.Mongo; import com.mongodb.MongoClient; /** @@ -107,7 +106,7 @@ public class ComplexIdRepositoryIntegrationTests { repo.save(userWithId); - assertThat(repo.findOne(id), is(Optional.of(userWithId))); + assertThat(repo.findById(id), is(Optional.of(userWithId))); } @Test // DATAMONGO-1078 @@ -115,7 +114,7 @@ public class ComplexIdRepositoryIntegrationTests { repo.save(userWithId); - Iterable loaded = repo.findAll(Collections.singleton(id)); + Iterable loaded = repo.findAllById(Collections.singleton(id)); assertThat(loaded, is(Matchers. iterableWithSize(1))); assertThat(loaded, contains(userWithId)); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ContactRepositoryIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ContactRepositoryIntegrationTests.java index 18e3202dc..035050de3 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ContactRepositoryIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ContactRepositoryIntegrationTests.java @@ -49,7 +49,7 @@ public class ContactRepositoryIntegrationTests { Person person = new Person("Oliver", "Gierke"); Contact result = repository.save(person); - assertTrue(repository.findOne(result.getId().toString()).get() instanceof Person); + assertTrue(repository.findById(result.getId().toString()).get() instanceof Person); } @Test // DATAMONGO-1245 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ConvertingReactiveMongoRepositoryTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ConvertingReactiveMongoRepositoryTests.java index 949063aac..51aa64f22 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ConvertingReactiveMongoRepositoryTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ConvertingReactiveMongoRepositoryTests.java @@ -84,14 +84,14 @@ public class ConvertingReactiveMongoRepositoryTests { leroi = new ReactivePerson("Leroi", "Moore", 41); alicia = new ReactivePerson("Alicia", "Keys", 30); - StepVerifier.create(reactiveRepository.save(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia))) // + StepVerifier.create(reactiveRepository.saveAll(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia))) // .expectNextCount(7) // .verifyComplete(); } @Test // DATAMONGO-1444 public void reactiveStreamsMethodsShouldWork() { - StepVerifier.create(reactivePersonRepostitory.exists(dave.getId())).expectNext(true).verifyComplete(); + StepVerifier.create(reactivePersonRepostitory.existsById(dave.getId())).expectNext(true).verifyComplete(); } @Test // DATAMONGO-1444 @@ -102,7 +102,7 @@ public class ConvertingReactiveMongoRepositoryTests { @Test // DATAMONGO-1444 public void simpleRxJava1MethodsShouldWork() throws Exception { - rxJava1PersonRepostitory.exists(dave.getId()) // + rxJava1PersonRepostitory.existsById(dave.getId()) // .test() // .awaitTerminalEvent() // .assertValue(true) // @@ -113,7 +113,7 @@ public class ConvertingReactiveMongoRepositoryTests { @Test // DATAMONGO-1444 public void existsWithSingleRxJava1IdMethodsShouldWork() throws Exception { - rxJava1PersonRepostitory.exists(Single.just(dave.getId())) // + rxJava1PersonRepostitory.existsById(Single.just(dave.getId())) // .test() // .awaitTerminalEvent() // .assertValue(true) // @@ -162,7 +162,7 @@ public class ConvertingReactiveMongoRepositoryTests { @Test // DATAMONGO-1610 public void simpleRxJava2MethodsShouldWork() throws Exception { - TestObserver testObserver = rxJava2PersonRepostitory.exists(dave.getId()).test(); + TestObserver testObserver = rxJava2PersonRepostitory.existsById(dave.getId()).test(); testObserver.awaitTerminalEvent(); testObserver.assertComplete(); @@ -173,7 +173,8 @@ public class ConvertingReactiveMongoRepositoryTests { @Test // DATAMONGO-1610 public void existsWithSingleRxJava2IdMethodsShouldWork() throws Exception { - TestObserver testObserver = rxJava2PersonRepostitory.exists(io.reactivex.Single.just(dave.getId())).test(); + TestObserver testObserver = rxJava2PersonRepostitory.existsById(io.reactivex.Single.just(dave.getId())) + .test(); testObserver.awaitTerminalEvent(); testObserver.assertComplete(); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/MongoRepositoryTextSearchIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/MongoRepositoryTextSearchIntegrationTests.java index cb5dd2971..a3cfc77ed 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/MongoRepositoryTextSearchIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/MongoRepositoryTextSearchIntegrationTests.java @@ -50,7 +50,6 @@ import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; import org.springframework.util.ClassUtils; import org.springframework.util.ObjectUtils; -import com.mongodb.Mongo; import com.mongodb.MongoClient; /** @@ -79,8 +78,8 @@ public class MongoRepositoryTextSearchIntegrationTests { @Before public void setUp() { - template.indexOps(FullTextDocument.class).ensureIndex( - new TextIndexDefinitionBuilder().onField("title").onField("content").build()); + template.indexOps(FullTextDocument.class) + .ensureIndex(new TextIndexDefinitionBuilder().onField("title").onField("content").build()); this.repo = new MongoRepositoryFactory(this.template).getRepository(FullTextRepository.class); } @@ -104,9 +103,7 @@ public class MongoRepositoryTextSearchIntegrationTests { public void derivedFinderWithTextCriteriaReturnsCorrectResult() { initRepoWithDefaultDocuments(); - FullTextDocument blade = new FullTextDocument( - "4", - "Blade", + FullTextDocument blade = new FullTextDocument("4", "Blade", "Blade is a 1998 American vampire-superhero-vigilante action film starring Wesley Snipes and Stephen Dorff, loosely based on the Marvel Comics character Blade"); blade.nonTextIndexProperty = "foo"; repo.save(blade); @@ -123,8 +120,8 @@ public class MongoRepositoryTextSearchIntegrationTests { initRepoWithDefaultDocuments(); - Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("film"), PageRequest.of(1, - 1, Direction.ASC, "id")); + Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("film"), + PageRequest.of(1, 1, Direction.ASC, "id")); assertThat(page.hasNext(), is(true)); assertThat(page.hasPrevious(), is(true)); @@ -139,8 +136,8 @@ public class MongoRepositoryTextSearchIntegrationTests { FullTextDocument snipes = new FullTextDocument("4", "Snipes", "Wesley Trent Snipes is an actor and film producer."); repo.save(snipes); - List result = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), Sort.by( - "score")); + List result = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), + Sort.by("score")); assertThat(result.size(), is(4)); assertThat(result.get(0), equalTo(snipes)); @@ -153,8 +150,8 @@ public class MongoRepositoryTextSearchIntegrationTests { FullTextDocument snipes = new FullTextDocument("4", "Snipes", "Wesley Trent Snipes is an actor and film producer."); repo.save(snipes); - Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), PageRequest.of( - 0, 10, Direction.ASC, "score")); + Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), + PageRequest.of(0, 10, Direction.ASC, "score")); assertThat(page.getTotalElements(), is(4L)); assertThat(page.getContent().get(0), equalTo(snipes)); @@ -167,8 +164,8 @@ public class MongoRepositoryTextSearchIntegrationTests { FullTextDocument snipes = new FullTextDocument("4", "Snipes", "Wesley Trent Snipes is an actor and film producer."); repo.save(snipes); - Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), PageRequest.of( - 0, 10, Direction.ASC, "id")); + Page page = repo.findAllBy(TextCriteria.forDefaultLanguage().matching("snipes"), + PageRequest.of(0, 10, Direction.ASC, "id")); assertThat(page.getTotalElements(), is(4L)); assertThat(page.getContent().get(0), equalTo(PASSENGER_57)); @@ -181,8 +178,8 @@ public class MongoRepositoryTextSearchIntegrationTests { FullTextDocument snipes = new FullTextDocument("4", "Snipes", "Wesley Trent Snipes is an actor and film producer."); repo.save(snipes); - List result = repo.findByNonTextIndexPropertyIsNullOrderByScoreDesc(TextCriteria - .forDefaultLanguage().matching("snipes")); + List result = repo + .findByNonTextIndexPropertyIsNullOrderByScoreDesc(TextCriteria.forDefaultLanguage().matching("snipes")); assertThat(result.get(0), equalTo(snipes)); } @@ -196,7 +193,7 @@ public class MongoRepositoryTextSearchIntegrationTests { } private void initRepoWithDefaultDocuments() { - repo.save(Arrays.asList(PASSENGER_57, DEMOLITION_MAN, DROP_ZONE)); + repo.saveAll(Arrays.asList(PASSENGER_57, DEMOLITION_MAN, DROP_ZONE)); } @org.springframework.context.annotation.Configuration diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepositoryLazyLoadingIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepositoryLazyLoadingIntegrationTests.java index d5775b972..11f112d84 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepositoryLazyLoadingIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/PersonRepositoryLazyLoadingIntegrationTests.java @@ -64,7 +64,7 @@ public class PersonRepositoryLazyLoadingIntegrationTests { person.setRealFans(new ArrayList(Arrays.asList(thomas))); repository.save(person); - Person oliver = repository.findOne(person.id).get(); + Person oliver = repository.findById(person.id).get(); List fans = oliver.getFans(); assertProxyIsResolved(fans, false); @@ -87,7 +87,7 @@ public class PersonRepositoryLazyLoadingIntegrationTests { person.setRealFans(new ArrayList(Arrays.asList(thomas))); repository.save(person); - Person oliver = repository.findOne(person.id).get(); + Person oliver = repository.findById(person.id).get(); List realFans = oliver.getRealFans(); assertProxyIsResolved(realFans, false); @@ -114,7 +114,7 @@ public class PersonRepositoryLazyLoadingIntegrationTests { person.setCoworker(thomas); repository.save(person); - Person oliver = repository.findOne(person.id).get(); + Person oliver = repository.findById(person.id).get(); User coworker = oliver.getCoworker(); diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ReactiveMongoRepositoryTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ReactiveMongoRepositoryTests.java index 602b1c2fe..3f5235a80 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ReactiveMongoRepositoryTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/ReactiveMongoRepositoryTests.java @@ -114,7 +114,7 @@ public class ReactiveMongoRepositoryTests implements BeanClassLoaderAware, BeanF alicia = new Person("Alicia", "Keys", 30, Sex.FEMALE); - StepVerifier.create(repository.save(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia))) // + StepVerifier.create(repository.saveAll(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia))) // .expectNextCount(7) // .verifyComplete(); } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/SimpleReactiveMongoRepositoryTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/SimpleReactiveMongoRepositoryTests.java index f4be5770f..e45044f1b 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/SimpleReactiveMongoRepositoryTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/SimpleReactiveMongoRepositoryTests.java @@ -95,49 +95,49 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, leroi = new ReactivePerson("Leroi", "Moore", 41); alicia = new ReactivePerson("Alicia", "Keys", 30); - StepVerifier.create(repository.save(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia))) // + StepVerifier.create(repository.saveAll(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia))) // .expectNextCount(7) // .verifyComplete(); } @Test // DATAMONGO-1444 public void existsByIdShouldReturnTrueForExistingObject() { - StepVerifier.create(repository.exists(dave.id)).expectNext(true).verifyComplete(); + StepVerifier.create(repository.existsById(dave.id)).expectNext(true).verifyComplete(); } @Test // DATAMONGO-1444 public void existsByIdShouldReturnFalseForAbsentObject() { - StepVerifier.create(repository.exists("unknown")).expectNext(false).verifyComplete(); + StepVerifier.create(repository.existsById("unknown")).expectNext(false).verifyComplete(); } @Test // DATAMONGO-1444 public void existsByMonoOfIdShouldReturnTrueForExistingObject() { - StepVerifier.create(repository.exists(Mono.just(dave.id))).expectNext(true).verifyComplete(); + StepVerifier.create(repository.existsById(Mono.just(dave.id))).expectNext(true).verifyComplete(); } @Test // DATAMONGO-1444 public void existsByEmptyMonoOfIdShouldReturnEmptyMono() { - StepVerifier.create(repository.exists(Mono.empty())).verifyComplete(); + StepVerifier.create(repository.existsById(Mono.empty())).verifyComplete(); } @Test // DATAMONGO-1444 public void findOneShouldReturnObject() { - StepVerifier.create(repository.findOne(dave.id)).expectNext(dave).verifyComplete(); + StepVerifier.create(repository.findById(dave.id)).expectNext(dave).verifyComplete(); } @Test // DATAMONGO-1444 public void findOneShouldCompleteWithoutValueForAbsentObject() { - StepVerifier.create(repository.findOne("unknown")).verifyComplete(); + StepVerifier.create(repository.findById("unknown")).verifyComplete(); } @Test // DATAMONGO-1444 public void findOneByMonoOfIdShouldReturnTrueForExistingObject() { - StepVerifier.create(repository.findOne(Mono.just(dave.id))).expectNext(dave).verifyComplete(); + StepVerifier.create(repository.findById(Mono.just(dave.id))).expectNext(dave).verifyComplete(); } @Test // DATAMONGO-1444 public void findOneByEmptyMonoOfIdShouldReturnEmptyMono() { - StepVerifier.create(repository.findOne(Mono.empty())).verifyComplete(); + StepVerifier.create(repository.findById(Mono.empty())).verifyComplete(); } @Test // DATAMONGO-1444 @@ -147,17 +147,17 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, @Test // DATAMONGO-1444 public void findAllByIterableOfIdShouldReturnResults() { - StepVerifier.create(repository.findAll(Arrays.asList(dave.id, boyd.id))).expectNextCount(2).verifyComplete(); + StepVerifier.create(repository.findAllById(Arrays.asList(dave.id, boyd.id))).expectNextCount(2).verifyComplete(); } @Test // DATAMONGO-1444 public void findAllByPublisherOfIdShouldReturnResults() { - StepVerifier.create(repository.findAll(Flux.just(dave.id, boyd.id))).expectNextCount(2).verifyComplete(); + StepVerifier.create(repository.findAllById(Flux.just(dave.id, boyd.id))).expectNextCount(2).verifyComplete(); } @Test // DATAMONGO-1444 public void findAllByEmptyPublisherOfIdShouldReturnResults() { - StepVerifier.create(repository.findAll(Flux.empty())).verifyComplete(); + StepVerifier.create(repository.findAllById(Flux.empty())).verifyComplete(); } @Test // DATAMONGO-1444 @@ -239,7 +239,7 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.findByLastname("Matthews")).expectNext(oliver).verifyComplete(); - StepVerifier.create(repository.findOne(dave.id)).consumeNextWith(actual -> { + StepVerifier.create(repository.findById(dave.id)).consumeNextWith(actual -> { assertThat(actual.getFirstname(), is(equalTo(dave.getFirstname()))); assertThat(actual.getLastname(), is(equalTo(dave.getLastname()))); @@ -253,7 +253,7 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.save(person)).expectNext(person).verifyComplete(); - StepVerifier.create(repository.findOne(person.id)).consumeNextWith(actual -> { + StepVerifier.create(repository.findById(person.id)).consumeNextWith(actual -> { assertThat(actual.getFirstname(), is(equalTo(person.getFirstname()))); assertThat(actual.getLastname(), is(equalTo(person.getLastname()))); @@ -269,7 +269,7 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, oliver.setId(null); boyd.setId(null); - StepVerifier.create(repository.save(Arrays.asList(dave, oliver, boyd))).expectNextCount(3).verifyComplete(); + StepVerifier.create(repository.saveAll(Arrays.asList(dave, oliver, boyd))).expectNextCount(3).verifyComplete(); assertThat(dave.getId(), is(notNullValue())); assertThat(oliver.getId(), is(notNullValue())); @@ -284,12 +284,12 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, dave.setFirstname("Hello, Dave"); dave.setLastname("Bowman"); - StepVerifier.create(repository.save(Arrays.asList(person, dave))).expectNextCount(2).verifyComplete(); + StepVerifier.create(repository.saveAll(Arrays.asList(person, dave))).expectNextCount(2).verifyComplete(); - StepVerifier.create(repository.findOne(dave.id)).expectNext(dave).verifyComplete(); + StepVerifier.create(repository.findById(dave.id)).expectNext(dave).verifyComplete(); assertThat(person.id, is(notNullValue())); - StepVerifier.create(repository.findOne(person.id)).expectNext(person).verifyComplete(); + StepVerifier.create(repository.findById(person.id)).expectNext(person).verifyComplete(); } @Test // DATAMONGO-1444 @@ -301,7 +301,7 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, oliver.setId(null); boyd.setId(null); - StepVerifier.create(repository.save(Flux.just(dave, oliver, boyd))).expectNextCount(3).verifyComplete(); + StepVerifier.create(repository.saveAll(Flux.just(dave, oliver, boyd))).expectNextCount(3).verifyComplete(); assertThat(dave.getId(), is(notNullValue())); assertThat(oliver.getId(), is(notNullValue())); @@ -319,9 +319,9 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, @Test // DATAMONGO-1444 public void deleteByIdShouldRemoveEntity() { - StepVerifier.create(repository.delete(dave.id)).verifyComplete(); + StepVerifier.create(repository.deleteById(dave.id)).verifyComplete(); - StepVerifier.create(repository.findOne(dave.id)).verifyComplete(); + StepVerifier.create(repository.findById(dave.id)).verifyComplete(); } @Test // DATAMONGO-1444 @@ -329,16 +329,16 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, StepVerifier.create(repository.delete(dave)).verifyComplete(); - StepVerifier.create(repository.findOne(dave.id)).verifyComplete(); + StepVerifier.create(repository.findById(dave.id)).verifyComplete(); } @Test // DATAMONGO-1444 public void deleteIterableOfEntitiesShouldRemoveEntities() { - StepVerifier.create(repository.delete(Arrays.asList(dave, boyd))).verifyComplete(); + StepVerifier.create(repository.deleteAll(Arrays.asList(dave, boyd))).verifyComplete(); - StepVerifier.create(repository.findOne(boyd.id)).verifyComplete(); + StepVerifier.create(repository.findById(boyd.id)).verifyComplete(); StepVerifier.create(repository.findByLastname("Matthews")).expectNext(oliver).verifyComplete(); } @@ -346,9 +346,9 @@ public class SimpleReactiveMongoRepositoryTests implements BeanClassLoaderAware, @Test // DATAMONGO-1444 public void deletePublisherOfEntitiesShouldRemoveEntities() { - StepVerifier.create(repository.delete(Flux.just(dave, boyd))).verifyComplete(); + StepVerifier.create(repository.deleteAll(Flux.just(dave, boyd))).verifyComplete(); - StepVerifier.create(repository.findOne(boyd.id)).verifyComplete(); + StepVerifier.create(repository.findById(boyd.id)).verifyComplete(); StepVerifier.create(repository.findByLastname("Matthews")).expectNext(oliver).verifyComplete(); } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiExtensionIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiExtensionIntegrationTests.java index 01e156b27..a6ed669c5 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiExtensionIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiExtensionIntegrationTests.java @@ -60,7 +60,7 @@ public class CdiExtensionIntegrationTests { Person result = repository.save(person); assertThat(result, is(notNullValue())); - assertThat(repository.findOne(person.getId()).get().getId(), is(result.getId())); + assertThat(repository.findById(person.getId()).get().getId(), is(result.getId())); } @Test // DATAMONGO-1017 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiPersonRepository.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiPersonRepository.java index a3a22586c..2127dfbaf 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiPersonRepository.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/cdi/CdiPersonRepository.java @@ -26,5 +26,5 @@ public interface CdiPersonRepository extends Repository { Person save(Person person); - Optional findOne(String id); + Optional findById(String id); } diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/StubParameterAccessor.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/StubParameterAccessor.java index 08525fef7..d5a3be002 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/StubParameterAccessor.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/query/StubParameterAccessor.java @@ -19,7 +19,6 @@ import java.util.Arrays; import java.util.Iterator; import java.util.Optional; -import jdk.nashorn.internal.runtime.regexp.joni.constants.OPCode; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Range; import org.springframework.data.domain.Sort; @@ -96,7 +95,7 @@ class StubParameterAccessor implements MongoParameterAccessor { * @see org.springframework.data.repository.query.ParameterAccessor#getSort() */ public Sort getSort() { - return null; + return Sort.unsorted(); } /* diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/QueryDslMongoRepositoryIntegrationTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/QueryDslMongoRepositoryIntegrationTests.java index fb9e8e4c9..f06034fda 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/QueryDslMongoRepositoryIntegrationTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/QueryDslMongoRepositoryIntegrationTests.java @@ -34,8 +34,6 @@ import org.springframework.data.mongodb.repository.query.MongoEntityInformation; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; -import com.querydsl.core.types.Predicate; - /** * Integration test for {@link QueryDslMongoRepository}. * @@ -68,7 +66,7 @@ public class QueryDslMongoRepositoryIntegrationTests { person = new QPerson("person"); - repository.save(Arrays.asList(oliver, dave, carter)); + repository.saveAll(Arrays.asList(oliver, dave, carter)); } @Test // DATAMONGO-1146 @@ -76,7 +74,6 @@ public class QueryDslMongoRepositoryIntegrationTests { assertThat(repository.exists(person.firstname.eq("Dave")), is(true)); assertThat(repository.exists(person.firstname.eq("Unknown")), is(false)); - assertThat(repository.exists((Predicate) null), is(true)); } @Test // DATAMONGO-1167 diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/SimpleMongoRepositoryTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/SimpleMongoRepositoryTests.java index 283fbdfa2..044df3a87 100755 --- a/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/SimpleMongoRepositoryTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/mongodb/repository/support/SimpleMongoRepositoryTests.java @@ -34,17 +34,17 @@ import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.data.domain.Example; +import org.springframework.data.domain.ExampleMatcher.StringMatcher; import org.springframework.data.domain.Page; import org.springframework.data.domain.PageRequest; -import org.springframework.data.domain.ExampleMatcher.*; import org.springframework.data.geo.Point; import org.springframework.data.mongodb.core.MongoTemplate; import org.springframework.data.mongodb.core.geo.GeoJsonPoint; import org.springframework.data.mongodb.core.mapping.Document; import org.springframework.data.mongodb.repository.Address; import org.springframework.data.mongodb.repository.Person; -import org.springframework.data.mongodb.repository.User; import org.springframework.data.mongodb.repository.Person.Sex; +import org.springframework.data.mongodb.repository.User; import org.springframework.data.mongodb.repository.query.MongoEntityInformation; import org.springframework.test.context.ContextConfiguration; import org.springframework.test.context.junit4.SpringJUnit4ClassRunner; @@ -81,7 +81,7 @@ public class SimpleMongoRepositoryTests { leroi = new Person("Leroi", "Moore", 41); alicia = new Person("Alicia", "Keys", 30, Sex.FEMALE); - all = repository.save(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia)); + all = repository.saveAll(Arrays.asList(oliver, dave, carter, boyd, stefan, leroi, alicia)); } @Test @@ -92,7 +92,7 @@ public class SimpleMongoRepositoryTests { @Test public void findOneFromCustomCollectionName() { - Person result = repository.findOne(dave.getId()).get(); + Person result = repository.findById(dave.getId()).get(); assertThat(result, is(dave)); } @@ -107,7 +107,7 @@ public class SimpleMongoRepositoryTests { @Test public void deleteByIdFromCustomCollectionName() { - repository.delete(dave.getId()); + repository.deleteById(dave.getId()); List result = repository.findAll(); assertThat(result, hasSize(all.size() - 1)); @@ -122,7 +122,7 @@ public class SimpleMongoRepositoryTests { Person person1 = new Person("First1" + randomId, "Last2" + randomId, 42); person1 = repository.insert(person1); - Person saved = repository.findOne(person1.getId()).get(); + Person saved = repository.findById(person1.getId()).get(); assertThat(saved, is(equalTo(person1))); }