From 26fa0c8285ec98904648a0f6f3a520cc7854a1ad Mon Sep 17 00:00:00 2001 From: Christoph Strobl Date: Fri, 8 May 2020 12:38:30 +0200 Subject: [PATCH] DATAMONGO-2538 - Delombok source files. Original pull request: #861. --- .../data/mongodb/core/AggregationUtil.java | 10 +- .../data/mongodb/core/ChangeStreamEvent.java | 31 +++- .../mongodb/core/ChangeStreamOptions.java | 42 ++++- .../data/mongodb/core/CollectionOptions.java | 10 +- .../mongodb/core/DefaultBulkOperations.java | 146 ++++++++++++++++-- .../data/mongodb/core/EntityOperations.java | 47 ++++-- ...ExecutableAggregationOperationSupport.java | 31 ++-- .../core/ExecutableFindOperationSupport.java | 35 +++-- .../ExecutableInsertOperationSupport.java | 30 ++-- .../ExecutableMapReduceOperationSupport.java | 12 +- .../ExecutableRemoveOperationSupport.java | 29 ++-- .../ExecutableUpdateOperationSupport.java | 47 +++--- .../data/mongodb/core/MappedDocument.java | 20 ++- .../core/MongoDatabaseFactorySupport.java | 50 +++++- .../data/mongodb/core/MongoTemplate.java | 61 +++++--- .../data/mongodb/core/PropertyOperations.java | 8 +- .../ReactiveAggregationOperationSupport.java | 23 +-- .../core/ReactiveFindOperationSupport.java | 34 ++-- .../core/ReactiveInsertOperationSupport.java | 26 ++-- .../ReactiveMapReduceOperationSupport.java | 9 +- .../mongodb/core/ReactiveMongoTemplate.java | 60 +++++-- .../core/ReactiveRemoveOperationSupport.java | 29 ++-- .../core/ReactiveUpdateOperationSupport.java | 51 +++--- .../SimpleReactiveMongoDatabaseFactory.java | 50 +++++- .../MongoPersistentEntityIndexResolver.java | 34 +++- .../core/index/PartialIndexFilter.java | 18 +-- .../core/messaging/ChangeStreamTask.java | 9 +- .../DefaultMessageListenerContainer.java | 28 +++- .../LazyMappingDelegatingMessage.java | 7 +- .../data/mongodb/core/messaging/Message.java | 34 +++- .../mongodb/core/messaging/SimpleMessage.java | 37 ++++- .../data/mongodb/core/query/Collation.java | 43 ++++-- .../data/mongodb/core/query/Field.java | 40 ++++- .../core/query/UntypedExampleMatcher.java | 32 +++- .../core/schema/DefaultMongoJsonSchema.java | 13 +- .../core/schema/DocumentJsonSchema.java | 13 +- .../mongodb/core/schema/JsonSchemaObject.java | 51 +++++- .../core/schema/JsonSchemaProperty.java | 8 +- .../core/schema/UntypedJsonSchemaObject.java | 14 +- .../core/validation/CriteriaValidator.java | 28 +++- .../core/validation/DocumentValidator.java | 29 +++- .../core/validation/JsonSchemaValidator.java | 29 +++- .../repository/query/AggregationUtils.java | 9 +- .../mongodb/repository/query/BooleanUtil.java | 9 +- .../repository/query/CollationUtils.java | 9 +- .../repository/query/MongoQueryExecution.java | 66 ++++++-- .../query/ReactiveMongoQueryExecution.java | 52 +++++-- .../query/SimpleMongoEntityMetadata.java | 8 +- .../ReactiveMongoRepositoryFactory.java | 13 +- .../SimpleReactiveMongoRepository.java | 17 +- .../util/json/ParameterBindingJsonReader.java | 35 ++++- 51 files changed, 1166 insertions(+), 410 deletions(-) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/AggregationUtil.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/AggregationUtil.java index e67773c1f..0f956a317 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/AggregationUtil.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/AggregationUtil.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AllArgsConstructor; - import java.util.Arrays; import java.util.Collections; import java.util.List; @@ -49,12 +47,18 @@ import org.springframework.util.ObjectUtils; * @author Mark Paluch * @since 2.1 */ -@AllArgsConstructor class AggregationUtil { QueryMapper queryMapper; MappingContext, MongoPersistentProperty> mappingContext; + AggregationUtil(QueryMapper queryMapper, + MappingContext, MongoPersistentProperty> mappingContext) { + + this.queryMapper = queryMapper; + this.mappingContext = mappingContext; + } + /** * Prepare the {@link AggregationOperationContext} for a given aggregation by either returning the context itself it * is not {@literal null}, create a {@link TypeBasedAggregationOperationContext} if the aggregation contains type diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ChangeStreamEvent.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ChangeStreamEvent.java index 8e1d3523c..a86dbc903 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ChangeStreamEvent.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ChangeStreamEvent.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.EqualsAndHashCode; - import java.time.Instant; import java.util.concurrent.atomic.AtomicReferenceFieldUpdater; @@ -27,6 +25,7 @@ import org.springframework.data.mongodb.core.convert.MongoConverter; import org.springframework.data.mongodb.core.messaging.Message; import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; +import org.springframework.util.ObjectUtils; import com.mongodb.client.model.changestream.ChangeStreamDocument; import com.mongodb.client.model.changestream.OperationType; @@ -39,7 +38,6 @@ import com.mongodb.client.model.changestream.OperationType; * @author Mark Paluch * @since 2.1 */ -@EqualsAndHashCode public class ChangeStreamEvent { @SuppressWarnings("rawtypes") // @@ -187,8 +185,8 @@ public class ChangeStreamEvent { return CONVERTED_UPDATER.compareAndSet(this, null, result) ? result : CONVERTED_UPDATER.get(this); } - throw new IllegalArgumentException(String.format("No converter found capable of converting %s to %s", - fullDocument.getClass(), targetType)); + throw new IllegalArgumentException( + String.format("No converter found capable of converting %s to %s", fullDocument.getClass(), targetType)); } /* @@ -199,4 +197,27 @@ public class ChangeStreamEvent { public String toString() { return "ChangeStreamEvent {" + "raw=" + raw + ", targetType=" + targetType + '}'; } + + @Override + public boolean equals(Object o) { + + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + ChangeStreamEvent that = (ChangeStreamEvent) o; + + if (!ObjectUtils.nullSafeEquals(this.raw, that.raw)) { + return false; + } + return ObjectUtils.nullSafeEquals(this.targetType, that.targetType); + } + + @Override + public int hashCode() { + int result = raw != null ? raw.hashCode() : 0; + result = 31 * result + ObjectUtils.nullSafeHashCode(targetType); + return result; + } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ChangeStreamOptions.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ChangeStreamOptions.java index 535e40a21..65f27f915 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ChangeStreamOptions.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ChangeStreamOptions.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.EqualsAndHashCode; - import java.time.Instant; import java.util.Arrays; import java.util.Optional; @@ -25,7 +23,6 @@ import org.bson.BsonDocument; import org.bson.BsonTimestamp; import org.bson.BsonValue; import org.bson.Document; - import org.springframework.data.mongodb.core.aggregation.Aggregation; import org.springframework.data.mongodb.core.query.Collation; import org.springframework.lang.Nullable; @@ -45,7 +42,6 @@ import com.mongodb.client.model.changestream.FullDocument; * @author Mark Paluch * @since 2.1 */ -@EqualsAndHashCode public class ChangeStreamOptions { private @Nullable Object filter; @@ -156,6 +152,44 @@ public class ChangeStreamOptions { + ObjectUtils.nullSafeClassName(timestamp)); } + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + ChangeStreamOptions that = (ChangeStreamOptions) o; + + if (!ObjectUtils.nullSafeEquals(this.filter, that.filter)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(this.resumeToken, that.resumeToken)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(this.fullDocumentLookup, that.fullDocumentLookup)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(this.collation, that.collation)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(this.resumeTimestamp, that.resumeTimestamp)) { + return false; + } + return resume == that.resume; + } + + @Override + public int hashCode() { + int result = ObjectUtils.nullSafeHashCode(filter); + result = 31 * result + ObjectUtils.nullSafeHashCode(resumeToken); + result = 31 * result + ObjectUtils.nullSafeHashCode(fullDocumentLookup); + result = 31 * result + ObjectUtils.nullSafeHashCode(collation); + result = 31 * result + ObjectUtils.nullSafeHashCode(resumeTimestamp); + result = 31 * result + ObjectUtils.nullSafeHashCode(resume); + return result; + } + /** * @author Christoph Strobl * @since 2.2 diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/CollectionOptions.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/CollectionOptions.java index 77833c6ad..8e4f1b1f4 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/CollectionOptions.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/CollectionOptions.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.RequiredArgsConstructor; - import java.util.Optional; import org.springframework.data.mongodb.core.query.Collation; @@ -312,7 +310,6 @@ public class CollectionOptions { * @author Andreas Zink * @since 2.1 */ - @RequiredArgsConstructor public static class ValidationOptions { private static final ValidationOptions NONE = new ValidationOptions(null, null, null); @@ -321,6 +318,13 @@ public class CollectionOptions { private final @Nullable ValidationLevel validationLevel; private final @Nullable ValidationAction validationAction; + public ValidationOptions(Validator validator, ValidationLevel validationLevel, ValidationAction validationAction) { + + this.validator = validator; + this.validationLevel = validationLevel; + this.validationAction = validationAction; + } + /** * Create an empty {@link ValidationOptions}. * diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultBulkOperations.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultBulkOperations.java index bbd99d3d8..10518301f 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultBulkOperations.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/DefaultBulkOperations.java @@ -15,9 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.NonNull; -import lombok.Value; - import java.util.ArrayList; import java.util.Collections; import java.util.List; @@ -47,6 +44,7 @@ import org.springframework.data.mongodb.core.query.UpdateDefinition.ArrayFilter; import org.springframework.data.util.Pair; import org.springframework.lang.Nullable; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; import com.mongodb.WriteConcern; import com.mongodb.bulk.BulkWriteResult; @@ -547,15 +545,93 @@ class DefaultBulkOperations implements BulkOperations { * @author Christoph Strobl * @since 2.0 */ - @Value - static class BulkOperationContext { + static final class BulkOperationContext { - @NonNull BulkMode bulkMode; - @NonNull Optional> entity; - @NonNull QueryMapper queryMapper; - @NonNull UpdateMapper updateMapper; - ApplicationEventPublisher eventPublisher; - EntityCallbacks entityCallbacks; + private final BulkMode bulkMode; + private final Optional> entity; + private final QueryMapper queryMapper; + private final UpdateMapper updateMapper; + private final ApplicationEventPublisher eventPublisher; + private final EntityCallbacks entityCallbacks; + + BulkOperationContext(BulkOperations.BulkMode bulkMode, Optional> entity, + QueryMapper queryMapper, UpdateMapper updateMapper, ApplicationEventPublisher eventPublisher, + EntityCallbacks entityCallbacks) { + + this.bulkMode = bulkMode; + this.entity = entity; + this.queryMapper = queryMapper; + this.updateMapper = updateMapper; + this.eventPublisher = eventPublisher; + this.entityCallbacks = entityCallbacks; + } + + public BulkMode getBulkMode() { + return this.bulkMode; + } + + public Optional> getEntity() { + return this.entity; + } + + public QueryMapper getQueryMapper() { + return this.queryMapper; + } + + public UpdateMapper getUpdateMapper() { + return this.updateMapper; + } + + public ApplicationEventPublisher getEventPublisher() { + return this.eventPublisher; + } + + public EntityCallbacks getEntityCallbacks() { + return this.entityCallbacks; + } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + BulkOperationContext that = (BulkOperationContext) o; + + if (bulkMode != that.bulkMode) + return false; + if (!ObjectUtils.nullSafeEquals(this.entity, that.entity)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(this.queryMapper, that.queryMapper)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(this.updateMapper, that.updateMapper)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(this.eventPublisher, that.eventPublisher)) { + return false; + } + return ObjectUtils.nullSafeEquals(this.entityCallbacks, that.entityCallbacks); + } + + @Override + public int hashCode() { + int result = bulkMode != null ? bulkMode.hashCode() : 0; + result = 31 * result + ObjectUtils.nullSafeHashCode(entity); + result = 31 * result + ObjectUtils.nullSafeHashCode(queryMapper); + result = 31 * result + ObjectUtils.nullSafeHashCode(updateMapper); + result = 31 * result + ObjectUtils.nullSafeHashCode(eventPublisher); + result = 31 * result + ObjectUtils.nullSafeHashCode(entityCallbacks); + return result; + } + + public String toString() { + return "DefaultBulkOperations.BulkOperationContext(bulkMode=" + this.getBulkMode() + ", entity=" + + this.getEntity() + ", queryMapper=" + this.getQueryMapper() + ", updateMapper=" + this.getUpdateMapper() + + ", eventPublisher=" + this.getEventPublisher() + ", entityCallbacks=" + this.getEntityCallbacks() + ")"; + } } /** @@ -564,10 +640,50 @@ class DefaultBulkOperations implements BulkOperations { * @since 2.2 * @author Christoph Strobl */ - @Value - private static class SourceAwareWriteModelHolder { + private static final class SourceAwareWriteModelHolder { - Object source; - WriteModel model; + private final Object source; + private final WriteModel model; + + SourceAwareWriteModelHolder(Object source, WriteModel model) { + + this.source = source; + this.model = model; + } + + public Object getSource() { + return this.source; + } + + public WriteModel getModel() { + return this.model; + } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + SourceAwareWriteModelHolder that = (SourceAwareWriteModelHolder) o; + + if (!ObjectUtils.nullSafeEquals(this.source, that.source)) { + return false; + } + return ObjectUtils.nullSafeEquals(this.model, that.model); + } + + @Override + public int hashCode() { + int result = ObjectUtils.nullSafeHashCode(model); + result = 31 * result + ObjectUtils.nullSafeHashCode(source); + return result; + } + + public String toString() { + return "DefaultBulkOperations.SourceAwareWriteModelHolder(source=" + this.getSource() + ", model=" + + this.getModel() + ")"; + } } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/EntityOperations.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/EntityOperations.java index a7cbf879e..db1d04d24 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/EntityOperations.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/EntityOperations.java @@ -15,10 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import java.util.Collection; import java.util.Map; import java.util.Optional; @@ -55,12 +51,15 @@ import org.springframework.util.MultiValueMap; * @see MongoTemplate * @see ReactiveMongoTemplate */ -@RequiredArgsConstructor class EntityOperations { private static final String ID_FIELD = "_id"; - private final @NonNull MappingContext, MongoPersistentProperty> context; + private final MappingContext, MongoPersistentProperty> context; + + EntityOperations(MappingContext, MongoPersistentProperty> context) { + this.context = context; + } /** * Creates a new {@link Entity} for the given bean. @@ -69,7 +68,7 @@ class EntityOperations { * @return new instance of {@link Entity}. */ @SuppressWarnings({ "unchecked", "rawtypes" }) - public Entity forEntity(T entity) { + Entity forEntity(T entity) { Assert.notNull(entity, "Bean must not be null!"); @@ -92,7 +91,7 @@ class EntityOperations { * @return new instance of {@link AdaptibleEntity}. */ @SuppressWarnings({ "unchecked", "rawtypes" }) - public AdaptibleEntity forEntity(T entity, ConversionService conversionService) { + AdaptibleEntity forEntity(T entity, ConversionService conversionService) { Assert.notNull(entity, "Bean must not be null!"); Assert.notNull(conversionService, "ConversionService must not be null!"); @@ -346,11 +345,14 @@ class EntityOperations { Number getVersion(); } - @RequiredArgsConstructor private static class UnmappedEntity> implements AdaptibleEntity { private final T map; + protected UnmappedEntity(T map) { + this.map = map; + } + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.EntityOperations.PersistableSource#getIdPropertyName() @@ -460,7 +462,7 @@ class EntityOperations { private static class SimpleMappedEntity> extends UnmappedEntity { - SimpleMappedEntity(T map) { + protected SimpleMappedEntity(T map) { super(map); } @@ -483,12 +485,19 @@ class EntityOperations { } } - @RequiredArgsConstructor(access = AccessLevel.PROTECTED) private static class MappedEntity implements Entity { - private final @NonNull MongoPersistentEntity entity; - private final @NonNull IdentifierAccessor idAccessor; - private final @NonNull PersistentPropertyAccessor propertyAccessor; + private final MongoPersistentEntity entity; + private final IdentifierAccessor idAccessor; + private final PersistentPropertyAccessor propertyAccessor; + + protected MappedEntity(MongoPersistentEntity entity, IdentifierAccessor idAccessor, + PersistentPropertyAccessor propertyAccessor) { + + this.entity = entity; + this.idAccessor = idAccessor; + this.propertyAccessor = propertyAccessor; + } private static MappedEntity of(T bean, MappingContext, MongoPersistentProperty> context) { @@ -759,11 +768,12 @@ class EntityOperations { * {@link TypedOperations} for generic entities that are not represented with {@link PersistentEntity} (e.g. custom * conversions). */ - @RequiredArgsConstructor enum UntypedOperations implements TypedOperations { INSTANCE; + UntypedOperations() {} + @SuppressWarnings({ "unchecked", "rawtypes" }) public static TypedOperations instance() { return (TypedOperations) INSTANCE; @@ -798,10 +808,13 @@ class EntityOperations { * * @param */ - @RequiredArgsConstructor static class TypedEntityOperations implements TypedOperations { - private final @NonNull MongoPersistentEntity entity; + private final MongoPersistentEntity entity; + + protected TypedEntityOperations(MongoPersistentEntity entity) { + this.entity = entity; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableAggregationOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableAggregationOperationSupport.java index 76ff13a02..0317b0189 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableAggregationOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableAggregationOperationSupport.java @@ -15,16 +15,10 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; - import org.springframework.data.mongodb.core.aggregation.Aggregation; import org.springframework.data.mongodb.core.aggregation.AggregationResults; import org.springframework.data.mongodb.core.aggregation.TypedAggregation; import org.springframework.data.util.CloseableIterator; -import org.springframework.lang.Nullable; import org.springframework.util.Assert; import org.springframework.util.StringUtils; @@ -35,10 +29,13 @@ import org.springframework.util.StringUtils; * @author Mark Paluch * @since 2.0 */ -@RequiredArgsConstructor class ExecutableAggregationOperationSupport implements ExecutableAggregationOperation { - private final @NonNull MongoTemplate template; + private final MongoTemplate template; + + ExecutableAggregationOperationSupport(MongoTemplate template) { + this.template = template; + } /* * (non-Javadoc) @@ -56,15 +53,21 @@ class ExecutableAggregationOperationSupport implements ExecutableAggregationOper * @author Christoph Strobl * @since 2.0 */ - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ExecutableAggregationSupport implements AggregationWithAggregation, ExecutableAggregation, TerminatingAggregation { - @NonNull MongoTemplate template; - @NonNull Class domainType; - @Nullable Aggregation aggregation; - @Nullable String collection; + private final MongoTemplate template; + private final Class domainType; + private final Aggregation aggregation; + private final String collection; + + public ExecutableAggregationSupport(MongoTemplate template, Class domainType, Aggregation aggregation, + String collection) { + this.template = template; + this.domainType = domainType; + this.aggregation = aggregation; + this.collection = collection; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableFindOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableFindOperationSupport.java index eac01e529..758112ef9 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableFindOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableFindOperationSupport.java @@ -15,12 +15,6 @@ */ package org.springframework.data.mongodb.core; -import com.mongodb.ReadPreference; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; - import java.util.List; import java.util.Optional; import java.util.stream.Stream; @@ -37,6 +31,7 @@ import org.springframework.util.Assert; import org.springframework.util.ObjectUtils; import org.springframework.util.StringUtils; +import com.mongodb.ReadPreference; import com.mongodb.client.FindIterable; /** @@ -46,12 +41,15 @@ import com.mongodb.client.FindIterable; * @author Mark Paluch * @since 2.0 */ -@RequiredArgsConstructor class ExecutableFindOperationSupport implements ExecutableFindOperation { private static final Query ALL_QUERY = new Query(); - private final @NonNull MongoTemplate template; + private final MongoTemplate template; + + ExecutableFindOperationSupport(MongoTemplate template) { + this.template = template; + } /* * (non-Javadoc) @@ -70,16 +68,23 @@ class ExecutableFindOperationSupport implements ExecutableFindOperation { * @author Christoph Strobl * @since 2.0 */ - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ExecutableFindSupport implements ExecutableFind, FindWithCollection, FindWithProjection, FindWithQuery { - @NonNull MongoTemplate template; - @NonNull Class domainType; - Class returnType; - @Nullable String collection; - Query query; + private final MongoTemplate template; + private final Class domainType; + private final Class returnType; + @Nullable private final String collection; + private final Query query; + + ExecutableFindSupport(MongoTemplate template, Class domainType, Class returnType, + String collection, Query query) { + this.template = template; + this.domainType = domainType; + this.returnType = returnType; + this.collection = collection; + this.query = query; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableInsertOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableInsertOperationSupport.java index a22625f7a..fe4a0a8ea 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableInsertOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableInsertOperationSupport.java @@ -15,11 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; - import java.util.ArrayList; import java.util.Collection; @@ -37,10 +32,13 @@ import com.mongodb.bulk.BulkWriteResult; * @author Mark Paluch * @since 2.0 */ -@RequiredArgsConstructor class ExecutableInsertOperationSupport implements ExecutableInsertOperation { - private final @NonNull MongoTemplate template; + private final MongoTemplate template; + + ExecutableInsertOperationSupport(MongoTemplate template) { + this.template = template; + } /* * (non-Javadoc) @@ -58,14 +56,20 @@ class ExecutableInsertOperationSupport implements ExecutableInsertOperation { * @author Christoph Strobl * @since 2.0 */ - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ExecutableInsertSupport implements ExecutableInsert { - @NonNull MongoTemplate template; - @NonNull Class domainType; - @Nullable String collection; - @Nullable BulkMode bulkMode; + private final MongoTemplate template; + private final Class domainType; + @Nullable private final String collection; + @Nullable private final BulkMode bulkMode; + + ExecutableInsertSupport(MongoTemplate template, Class domainType, String collection, BulkMode bulkMode) { + + this.template = template; + this.domainType = domainType; + this.collection = collection; + this.bulkMode = bulkMode; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableMapReduceOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableMapReduceOperationSupport.java index 57e9d38cc..96f581d55 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableMapReduceOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableMapReduceOperationSupport.java @@ -15,9 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import java.util.List; import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions; @@ -32,12 +29,17 @@ import org.springframework.util.StringUtils; * @author Christoph Strobl * @since 2.1 */ -@RequiredArgsConstructor class ExecutableMapReduceOperationSupport implements ExecutableMapReduceOperation { private static final Query ALL_QUERY = new Query(); - private final @NonNull MongoTemplate template; + private final MongoTemplate template; + + ExecutableMapReduceOperationSupport(MongoTemplate template) { + + Assert.notNull(template, "Template must not be null!"); + this.template = template; + } /* * (non-Javascript) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableRemoveOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableRemoveOperationSupport.java index edba892a0..7b3952206 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableRemoveOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableRemoveOperationSupport.java @@ -15,11 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; - import java.util.List; import org.springframework.data.mongodb.core.query.Query; @@ -36,12 +31,15 @@ import com.mongodb.client.result.DeleteResult; * @author Mark Paluch * @since 2.0 */ -@RequiredArgsConstructor class ExecutableRemoveOperationSupport implements ExecutableRemoveOperation { private static final Query ALL_QUERY = new Query(); - private final @NonNull MongoTemplate tempate; + private final MongoTemplate tempate; + + public ExecutableRemoveOperationSupport(MongoTemplate tempate) { + this.tempate = tempate; + } /* * (non-Javadoc) @@ -59,14 +57,19 @@ class ExecutableRemoveOperationSupport implements ExecutableRemoveOperation { * @author Christoph Strobl * @since 2.0 */ - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ExecutableRemoveSupport implements ExecutableRemove, RemoveWithCollection { - @NonNull MongoTemplate template; - @NonNull Class domainType; - Query query; - @Nullable String collection; + private final MongoTemplate template; + private final Class domainType; + private final Query query; + @Nullable private final String collection; + + public ExecutableRemoveSupport(MongoTemplate template, Class domainType, Query query, String collection) { + this.template = template; + this.domainType = domainType; + this.query = query; + this.collection = collection; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableUpdateOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableUpdateOperationSupport.java index 0d84c56f9..f5ed3740e 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableUpdateOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ExecutableUpdateOperationSupport.java @@ -15,11 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; - import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.mongodb.core.query.UpdateDefinition; import org.springframework.lang.Nullable; @@ -35,12 +30,15 @@ import com.mongodb.client.result.UpdateResult; * @author Mark Paluch * @since 2.0 */ -@RequiredArgsConstructor class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation { private static final Query ALL_QUERY = new Query(); - private final @NonNull MongoTemplate template; + private final MongoTemplate template; + + ExecutableUpdateOperationSupport(MongoTemplate template) { + this.template = template; + } /* * (non-Javadoc) @@ -58,21 +56,34 @@ class ExecutableUpdateOperationSupport implements ExecutableUpdateOperation { * @author Christoph Strobl * @since 2.0 */ - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ExecutableUpdateSupport implements ExecutableUpdate, UpdateWithCollection, UpdateWithQuery, TerminatingUpdate, FindAndReplaceWithOptions, TerminatingFindAndReplace, FindAndReplaceWithProjection { - @NonNull MongoTemplate template; - @NonNull Class domainType; - Query query; - @Nullable UpdateDefinition update; - @Nullable String collection; - @Nullable FindAndModifyOptions findAndModifyOptions; - @Nullable FindAndReplaceOptions findAndReplaceOptions; - @Nullable Object replacement; - @NonNull Class targetType; + private final MongoTemplate template; + private final Class domainType; + private final Query query; + @Nullable private final UpdateDefinition update; + @Nullable private final String collection; + @Nullable private final FindAndModifyOptions findAndModifyOptions; + @Nullable private final FindAndReplaceOptions findAndReplaceOptions; + @Nullable private final Object replacement; + private final Class targetType; + + ExecutableUpdateSupport(MongoTemplate template, Class domainType, Query query, UpdateDefinition update, + String collection, FindAndModifyOptions findAndModifyOptions, FindAndReplaceOptions findAndReplaceOptions, + Object replacement, Class targetType) { + + this.template = template; + this.domainType = domainType; + this.query = query; + this.update = update; + this.collection = collection; + this.findAndModifyOptions = findAndModifyOptions; + this.findAndReplaceOptions = findAndReplaceOptions; + this.replacement = replacement; + this.targetType = targetType; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MappedDocument.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MappedDocument.java index 7df9503ca..2c14a5baf 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MappedDocument.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MappedDocument.java @@ -15,9 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import java.util.Collection; import java.util.List; @@ -27,8 +24,6 @@ import org.springframework.data.mongodb.core.query.Update; import org.springframework.data.mongodb.core.query.UpdateDefinition; import org.springframework.data.util.StreamUtils; -import com.mongodb.client.model.Filters; - /** * A MongoDB document in its mapped state. I.e. after a source document has been mapped using mapping information of the * entity the source document was supposed to represent. @@ -36,13 +31,20 @@ import com.mongodb.client.model.Filters; * @author Oliver Gierke * @since 2.1 */ -@RequiredArgsConstructor(staticName = "of") public class MappedDocument { private static final String ID_FIELD = "_id"; private static final Document ID_ONLY_PROJECTION = new Document(ID_FIELD, 1); - private final @Getter Document document; + private final Document document; + + private MappedDocument(Document document) { + this.document = document; + } + + public static MappedDocument of(Document document) { + return new MappedDocument(document); + } public static Document getIdOnlyProjection() { return ID_ONLY_PROJECTION; @@ -91,6 +93,10 @@ public class MappedDocument { return new MappedUpdate(Update.fromDocument(document, ID_FIELD)); } + public Document getDocument() { + return this.document; + } + /** * An {@link UpdateDefinition} that indicates that the {@link #getUpdateObject() update object} has already been * mapped to the specific domain type. diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoDatabaseFactorySupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoDatabaseFactorySupport.java index 60f1ed56a..c716015ee 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoDatabaseFactorySupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoDatabaseFactorySupport.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.Value; - import org.springframework.aop.framework.ProxyFactory; import org.springframework.dao.DataAccessException; import org.springframework.dao.support.PersistenceExceptionTranslator; @@ -24,6 +22,7 @@ import org.springframework.data.mongodb.MongoDatabaseFactory; import org.springframework.data.mongodb.SessionAwareMethodInterceptor; import org.springframework.lang.Nullable; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; import com.mongodb.ClientSessionOptions; import com.mongodb.WriteConcern; @@ -171,11 +170,15 @@ public abstract class MongoDatabaseFactorySupport implements MongoDatabaseFac * @author Christoph Strobl * @since 2.1 */ - @Value - static class ClientSessionBoundMongoDbFactory implements MongoDatabaseFactory { + static final class ClientSessionBoundMongoDbFactory implements MongoDatabaseFactory { - ClientSession session; - MongoDatabaseFactory delegate; + private final ClientSession session; + private final MongoDatabaseFactory delegate; + + public ClientSessionBoundMongoDbFactory(ClientSession session, MongoDatabaseFactory delegate) { + this.session = session; + this.delegate = delegate; + } /* * (non-Javadoc) @@ -256,5 +259,40 @@ public abstract class MongoDatabaseFactorySupport implements MongoDatabaseFac return targetType.cast(factory.getProxy()); } + + public ClientSession getSession() { + return this.session; + } + + public MongoDatabaseFactory getDelegate() { + return this.delegate; + } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + ClientSessionBoundMongoDbFactory that = (ClientSessionBoundMongoDbFactory) o; + + if (!ObjectUtils.nullSafeEquals(this.session, that.session)) { + return false; + } + return ObjectUtils.nullSafeEquals(this.delegate, that.delegate); + } + + @Override + public int hashCode() { + int result = ObjectUtils.nullSafeHashCode(this.session); + result = 31 * result + ObjectUtils.nullSafeHashCode(this.delegate); + return result; + } + + public String toString() { + return "MongoDatabaseFactorySupport.ClientSessionBoundMongoDbFactory(session=" + this.getSession() + ", delegate=" + + this.getDelegate() + ")"; + } } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java index b70ddcbb6..3dc23dd94 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java @@ -17,11 +17,6 @@ package org.springframework.data.mongodb.core; import static org.springframework.data.mongodb.core.query.SerializationUtils.*; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import java.io.IOException; import java.math.BigDecimal; import java.math.RoundingMode; @@ -33,7 +28,6 @@ import org.bson.Document; import org.bson.conversions.Bson; import org.slf4j.Logger; import org.slf4j.LoggerFactory; - import org.springframework.beans.BeansException; import org.springframework.context.ApplicationContext; import org.springframework.context.ApplicationContextAware; @@ -2950,12 +2944,17 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, * @author Christoph Strobl * @since 2.0 */ - @RequiredArgsConstructor private class ExistsCallback implements CollectionCallback { private final Document mappedQuery; private final com.mongodb.client.model.Collation collation; + ExistsCallback(Document mappedQuery, com.mongodb.client.model.Collation collation) { + + this.mappedQuery = mappedQuery; + this.collation = collation; + } + @Override public Boolean doInCollection(MongoCollection collection) throws MongoException, DataAccessException { @@ -2977,7 +2976,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, private final Document sort; private final Optional collation; - public FindAndRemoveCallback(Document query, Document fields, Document sort, @Nullable Collation collation) { + FindAndRemoveCallback(Document query, Document fields, Document sort, @Nullable Collation collation) { this.query = query; this.fields = fields; @@ -3003,8 +3002,9 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, private final List arrayFilters; private final FindAndModifyOptions options; - public FindAndModifyCallback(Document query, Document fields, Document sort, Object update, + FindAndModifyCallback(Document query, Document fields, Document sort, Object update, List arrayFilters, FindAndModifyOptions options) { + this.query = query; this.fields = fields; this.sort = sort; @@ -3113,13 +3113,19 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, * @author Christoph Strobl * @author Roman Puchkovskiy */ - @RequiredArgsConstructor private class ReadDocumentCallback implements DocumentCallback { - private final @NonNull EntityReader reader; - private final @NonNull Class type; + private final EntityReader reader; + private final Class type; private final String collectionName; + ReadDocumentCallback(EntityReader reader, Class type, String collectionName) { + + this.reader = reader; + this.type = type; + this.collectionName = collectionName; + } + @Nullable public T doWith(@Nullable Document document) { @@ -3147,13 +3153,21 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, * @param * @since 2.0 */ - @RequiredArgsConstructor private class ProjectingReadCallback implements DocumentCallback { - private final @NonNull EntityReader reader; - private final @NonNull Class entityType; - private final @NonNull Class targetType; - private final @NonNull String collectionName; + private final EntityReader reader; + private final Class entityType; + private final Class targetType; + private final String collectionName; + + ProjectingReadCallback(EntityReader reader, Class entityType, Class targetType, + String collectionName) { + + this.reader = reader; + this.entityType = entityType; + this.targetType = targetType; + this.collectionName = collectionName; + } /* * (non-Javadoc) @@ -3189,7 +3203,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, private final Query query; private final @Nullable Class type; - public QueryCursorPreparer(Query query, @Nullable Class type) { + QueryCursorPreparer(Query query, @Nullable Class type) { this.query = query; this.type = type; @@ -3331,7 +3345,6 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, * @author Thomas Darimont * @since 1.7 */ - @AllArgsConstructor(access = AccessLevel.PACKAGE) static class CloseableIterableCursorAdapter implements CloseableIterator { private volatile @Nullable MongoCursor cursor; @@ -3345,7 +3358,7 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, * @param exceptionTranslator * @param objectReadCallback */ - public CloseableIterableCursorAdapter(MongoIterable cursor, + CloseableIterableCursorAdapter(MongoIterable cursor, PersistenceExceptionTranslator exceptionTranslator, DocumentCallback objectReadCallback) { this.cursor = cursor.iterator(); @@ -3353,6 +3366,14 @@ public class MongoTemplate implements MongoOperations, ApplicationContextAware, this.objectReadCallback = objectReadCallback; } + CloseableIterableCursorAdapter(MongoCursor cursor, PersistenceExceptionTranslator exceptionTranslator, + DocumentCallback objectReadCallback) { + + this.cursor = cursor; + this.exceptionTranslator = exceptionTranslator; + this.objectReadCallback = objectReadCallback; + } + @Override public boolean hasNext() { diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/PropertyOperations.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/PropertyOperations.java index 6afb8e940..f84bba4c2 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/PropertyOperations.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/PropertyOperations.java @@ -15,9 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.RequiredArgsConstructor; - import org.bson.Document; import org.springframework.data.mapping.SimplePropertyHandler; import org.springframework.data.mapping.context.MappingContext; @@ -33,11 +30,14 @@ import org.springframework.util.ClassUtils; * @author Christoph Strobl * @since 2.1 */ -@RequiredArgsConstructor(access = AccessLevel.PACKAGE) class PropertyOperations { private final MappingContext, MongoPersistentProperty> mappingContext; + PropertyOperations(MappingContext, MongoPersistentProperty> mappingContext) { + this.mappingContext = mappingContext; + } + /** * For cases where {@code fields} is {@link Document#isEmpty() empty} include only fields that are required for * creating the projection (target) type if the {@code targetType} is a {@literal DTO projection} or a diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveAggregationOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveAggregationOperationSupport.java index ce512b261..77c688c77 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveAggregationOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveAggregationOperationSupport.java @@ -15,10 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; import reactor.core.publisher.Flux; import org.springframework.data.mongodb.core.aggregation.Aggregation; @@ -62,15 +58,22 @@ class ReactiveAggregationOperationSupport implements ReactiveAggregationOperatio return new ReactiveAggregationSupport<>(template, domainType, null, null); } - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ReactiveAggregationSupport implements AggregationOperationWithAggregation, ReactiveAggregation, TerminatingAggregationOperation { - @NonNull ReactiveMongoTemplate template; - @NonNull Class domainType; - Aggregation aggregation; - String collection; + private final ReactiveMongoTemplate template; + private final Class domainType; + private final Aggregation aggregation; + private final String collection; + + ReactiveAggregationSupport(ReactiveMongoTemplate template, Class domainType, Aggregation aggregation, + String collection) { + + this.template = template; + this.domainType = domainType; + this.aggregation = aggregation; + this.collection = collection; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveFindOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveFindOperationSupport.java index b05204a7e..37aa0d38f 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveFindOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveFindOperationSupport.java @@ -15,15 +15,10 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import org.bson.Document; - import org.springframework.dao.IncorrectResultSizeDataAccessException; import org.springframework.data.mongodb.core.query.NearQuery; import org.springframework.data.mongodb.core.query.Query; @@ -39,12 +34,15 @@ import org.springframework.util.StringUtils; * @author Christoph Strobl * @since 2.0 */ -@RequiredArgsConstructor class ReactiveFindOperationSupport implements ReactiveFindOperation { private static final Query ALL_QUERY = new Query(); - private final @NonNull ReactiveMongoTemplate template; + private final ReactiveMongoTemplate template; + + ReactiveFindOperationSupport(ReactiveMongoTemplate template) { + this.template = template; + } /* * (non-Javadoc) @@ -64,16 +62,24 @@ class ReactiveFindOperationSupport implements ReactiveFindOperation { * @author Christoph Strobl * @since 2.0 */ - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ReactiveFindSupport implements ReactiveFind, FindWithCollection, FindWithProjection, FindWithQuery { - @NonNull ReactiveMongoTemplate template; - @NonNull Class domainType; - Class returnType; - String collection; - Query query; + private final ReactiveMongoTemplate template; + private final Class domainType; + private final Class returnType; + private final String collection; + private final Query query; + + ReactiveFindSupport(ReactiveMongoTemplate template, Class domainType, Class returnType, + String collection, Query query) { + + this.template = template; + this.domainType = domainType; + this.returnType = returnType; + this.collection = collection; + this.query = query; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveInsertOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveInsertOperationSupport.java index e0fc029bb..bc7eab0cc 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveInsertOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveInsertOperationSupport.java @@ -15,10 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @@ -34,10 +30,13 @@ import org.springframework.util.StringUtils; * @author Christoph Strobl * @since 2.0 */ -@RequiredArgsConstructor class ReactiveInsertOperationSupport implements ReactiveInsertOperation { - private final @NonNull ReactiveMongoTemplate template; + private final ReactiveMongoTemplate template; + + ReactiveInsertOperationSupport(ReactiveMongoTemplate template) { + this.template = template; + } /* * (non-Javadoc) @@ -51,13 +50,18 @@ class ReactiveInsertOperationSupport implements ReactiveInsertOperation { return new ReactiveInsertSupport<>(template, domainType, null); } - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ReactiveInsertSupport implements ReactiveInsert { - @NonNull ReactiveMongoTemplate template; - @NonNull Class domainType; - String collection; + private final ReactiveMongoTemplate template; + private final Class domainType; + private final String collection; + + ReactiveInsertSupport(ReactiveMongoTemplate template, Class domainType, String collection) { + + this.template = template; + this.domainType = domainType; + this.collection = collection; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMapReduceOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMapReduceOperationSupport.java index 4f9d5669f..e76417beb 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMapReduceOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMapReduceOperationSupport.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; import reactor.core.publisher.Flux; import org.springframework.data.mongodb.core.mapreduce.MapReduceOptions; @@ -31,12 +29,15 @@ import org.springframework.util.StringUtils; * @author Christoph Strobl * @since 2.1 */ -@RequiredArgsConstructor class ReactiveMapReduceOperationSupport implements ReactiveMapReduceOperation { private static final Query ALL_QUERY = new Query(); - private final @NonNull ReactiveMongoTemplate template; + private final ReactiveMongoTemplate template; + + ReactiveMapReduceOperationSupport(ReactiveMongoTemplate template) { + this.template = template; + } /* * (non-Javascript) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMongoTemplate.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMongoTemplate.java index 9bfcc533f..5abf54a2e 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMongoTemplate.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveMongoTemplate.java @@ -17,9 +17,6 @@ package org.springframework.data.mongodb.core; import static org.springframework.data.mongodb.core.query.SerializationUtils.*; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import reactor.util.function.Tuple2; @@ -2410,8 +2407,8 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati * @param query the query document that specifies the criteria used to find a record. * @param fields the document that specifies the fields to be returned. * @param entityClass the parameterized type of the returned list. - * @param preparer allows for customization of the {@link com.mongodb.client.FindIterable} used when iterating over the result set, (apply - * limits, skips and so on). + * @param preparer allows for customization of the {@link com.mongodb.client.FindIterable} used when iterating over + * the result set, (apply limits, skips and so on). * @return the {@link List} of converted objects. */ protected Flux doFind(String collectionName, Document query, Document fields, Class entityClass, @@ -2885,7 +2882,6 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati * * @author Mark Paluch */ - @RequiredArgsConstructor private static class FindCallback implements ReactiveCollectionQueryCallback { private final @Nullable Document query; @@ -2895,6 +2891,12 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati this(query, null); } + FindCallback(Document query, Document fields) { + + this.query = query; + this.fields = fields; + } + @Override public FindPublisher doInCollection(MongoCollection collection) { @@ -2948,7 +2950,6 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati /** * @author Mark Paluch */ - @RequiredArgsConstructor private static class FindAndModifyCallback implements ReactiveCollectionCallback { private final Document query; @@ -2958,6 +2959,17 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati private final List arrayFilters; private final FindAndModifyOptions options; + FindAndModifyCallback(Document query, Document fields, Document sort, Object update, List arrayFilters, + FindAndModifyOptions options) { + + this.query = query; + this.fields = fields; + this.sort = sort; + this.update = update; + this.arrayFilters = arrayFilters; + this.options = options; + } + @Override public Publisher doInCollection(MongoCollection collection) throws MongoException, DataAccessException { @@ -3013,7 +3025,6 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati * @author Christoph Strobl * @since 2.1 */ - @RequiredArgsConstructor(access = AccessLevel.PACKAGE) private static class FindAndReplaceCallback implements ReactiveCollectionCallback { private final Document query; @@ -3023,6 +3034,17 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati private final @Nullable com.mongodb.client.model.Collation collation; private final FindAndReplaceOptions options; + FindAndReplaceCallback(Document query, Document fields, Document sort, Document update, + com.mongodb.client.model.Collation collation, FindAndReplaceOptions options) { + + this.query = query; + this.fields = fields; + this.sort = sort; + this.update = update; + this.collation = collation; + this.options = options; + } + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.ReactiveCollectionCallback#doInCollection(com.mongodb.reactivestreams.client.MongoCollection) @@ -3139,13 +3161,20 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati * @author Roman Puchkovskiy * @since 2.0 */ - @RequiredArgsConstructor private class ProjectingReadCallback implements DocumentCallback { - private final @NonNull EntityReader reader; - private final @NonNull Class entityType; - private final @NonNull Class targetType; - private final @NonNull String collectionName; + private final EntityReader reader; + private final Class entityType; + private final Class targetType; + private final String collectionName; + + ProjectingReadCallback(EntityReader reader, Class entityType, Class targetType, + String collectionName) { + this.reader = reader; + this.entityType = entityType; + this.targetType = targetType; + this.collectionName = collectionName; + } @SuppressWarnings("unchecked") public Mono doWith(Document document) { @@ -3365,11 +3394,14 @@ public class ReactiveMongoTemplate implements ReactiveMongoOperations, Applicati } } - @RequiredArgsConstructor class IndexCreatorEventListener implements ApplicationListener> { final Consumer subscriptionExceptionHandler; + public IndexCreatorEventListener(Consumer subscriptionExceptionHandler) { + this.subscriptionExceptionHandler = subscriptionExceptionHandler; + } + @Override public void onApplicationEvent(MappingContextEvent event) { diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveRemoveOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveRemoveOperationSupport.java index 62835c023..98ef34a78 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveRemoveOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveRemoveOperationSupport.java @@ -15,10 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; @@ -35,12 +31,15 @@ import com.mongodb.client.result.DeleteResult; * @author Christoph Strobl * @since 2.0 */ -@RequiredArgsConstructor class ReactiveRemoveOperationSupport implements ReactiveRemoveOperation { private static final Query ALL_QUERY = new Query(); - private final @NonNull ReactiveMongoTemplate tempate; + private final ReactiveMongoTemplate tempate; + + ReactiveRemoveOperationSupport(ReactiveMongoTemplate tempate) { + this.tempate = tempate; + } /* * (non-Javadoc) @@ -54,14 +53,20 @@ class ReactiveRemoveOperationSupport implements ReactiveRemoveOperation { return new ReactiveRemoveSupport<>(tempate, domainType, ALL_QUERY, null); } - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ReactiveRemoveSupport implements ReactiveRemove, RemoveWithCollection { - @NonNull ReactiveMongoTemplate template; - @NonNull Class domainType; - Query query; - String collection; + private final ReactiveMongoTemplate template; + private final Class domainType; + private final Query query; + private final String collection; + + ReactiveRemoveSupport(ReactiveMongoTemplate template, Class domainType, Query query, String collection) { + + this.template = template; + this.domainType = domainType; + this.query = query; + this.collection = collection; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveUpdateOperationSupport.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveUpdateOperationSupport.java index ff1aede22..d723e1e33 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveUpdateOperationSupport.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/ReactiveUpdateOperationSupport.java @@ -15,13 +15,10 @@ */ package org.springframework.data.mongodb.core; -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; -import lombok.experimental.FieldDefaults; import reactor.core.publisher.Mono; import org.springframework.data.mongodb.core.query.Query; +import org.springframework.data.mongodb.core.query.UpdateDefinition; import org.springframework.lang.Nullable; import org.springframework.util.Assert; import org.springframework.util.StringUtils; @@ -35,12 +32,15 @@ import com.mongodb.client.result.UpdateResult; * @author Christoph Strobl * @since 2.0 */ -@RequiredArgsConstructor class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation { private static final Query ALL_QUERY = new Query(); - private final @NonNull ReactiveMongoTemplate template; + private final ReactiveMongoTemplate template; + + ReactiveUpdateOperationSupport(ReactiveMongoTemplate template) { + this.template = template; + } /* * (non-Javadoc) @@ -54,21 +54,34 @@ class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation { return new ReactiveUpdateSupport<>(template, domainType, ALL_QUERY, null, null, null, null, null, domainType); } - @RequiredArgsConstructor - @FieldDefaults(level = AccessLevel.PRIVATE, makeFinal = true) static class ReactiveUpdateSupport implements ReactiveUpdate, UpdateWithCollection, UpdateWithQuery, TerminatingUpdate, FindAndReplaceWithOptions, FindAndReplaceWithProjection, TerminatingFindAndReplace { - @NonNull ReactiveMongoTemplate template; - @NonNull Class domainType; - Query query; - org.springframework.data.mongodb.core.query.UpdateDefinition update; - @Nullable String collection; - @Nullable FindAndModifyOptions findAndModifyOptions; - @Nullable FindAndReplaceOptions findAndReplaceOptions; - @Nullable Object replacement; - @NonNull Class targetType; + private final ReactiveMongoTemplate template; + private final Class domainType; + private final Query query; + private final org.springframework.data.mongodb.core.query.UpdateDefinition update; + @Nullable private final String collection; + @Nullable private final FindAndModifyOptions findAndModifyOptions; + @Nullable private final FindAndReplaceOptions findAndReplaceOptions; + @Nullable private final Object replacement; + private final Class targetType; + + ReactiveUpdateSupport(ReactiveMongoTemplate template, Class domainType, Query query, UpdateDefinition update, + String collection, FindAndModifyOptions findAndModifyOptions, FindAndReplaceOptions findAndReplaceOptions, + Object replacement, Class targetType) { + + this.template = template; + this.domainType = domainType; + this.query = query; + this.update = update; + this.collection = collection; + this.findAndModifyOptions = findAndModifyOptions; + this.findAndReplaceOptions = findAndReplaceOptions; + this.replacement = replacement; + this.targetType = targetType; + } /* * (non-Javadoc) @@ -123,7 +136,9 @@ class ReactiveUpdateOperationSupport implements ReactiveUpdateOperation { String collectionName = getCollectionName(); - return template.findAndModify(query, update, findAndModifyOptions != null ? findAndModifyOptions : FindAndModifyOptions.none(), targetType, collectionName); + return template.findAndModify(query, update, + findAndModifyOptions != null ? findAndModifyOptions : FindAndModifyOptions.none(), targetType, + collectionName); } /* diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/SimpleReactiveMongoDatabaseFactory.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/SimpleReactiveMongoDatabaseFactory.java index 4eedce82a..603e8d027 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/SimpleReactiveMongoDatabaseFactory.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/SimpleReactiveMongoDatabaseFactory.java @@ -15,7 +15,6 @@ */ package org.springframework.data.mongodb.core; -import lombok.Value; import reactor.core.publisher.Mono; import org.bson.codecs.configuration.CodecRegistry; @@ -27,6 +26,7 @@ import org.springframework.data.mongodb.ReactiveMongoDatabaseFactory; import org.springframework.data.mongodb.SessionAwareMethodInterceptor; import org.springframework.lang.Nullable; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; import com.mongodb.ClientSessionOptions; import com.mongodb.ConnectionString; @@ -175,11 +175,16 @@ public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, React * @author Christoph Strobl * @since 2.1 */ - @Value - static class ClientSessionBoundMongoDbFactory implements ReactiveMongoDatabaseFactory { + static final class ClientSessionBoundMongoDbFactory implements ReactiveMongoDatabaseFactory { - ClientSession session; - ReactiveMongoDatabaseFactory delegate; + private final ClientSession session; + private final ReactiveMongoDatabaseFactory delegate; + + ClientSessionBoundMongoDbFactory(ClientSession session, ReactiveMongoDatabaseFactory delegate) { + + this.session = session; + this.delegate = delegate; + } /* * (non-Javadoc) @@ -268,5 +273,40 @@ public class SimpleReactiveMongoDatabaseFactory implements DisposableBean, React return targetType.cast(factory.getProxy()); } + + public ClientSession getSession() { + return this.session; + } + + public ReactiveMongoDatabaseFactory getDelegate() { + return this.delegate; + } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + ClientSessionBoundMongoDbFactory that = (ClientSessionBoundMongoDbFactory) o; + + if (!ObjectUtils.nullSafeEquals(this.session, that.session)) { + return false; + } + return ObjectUtils.nullSafeEquals(this.delegate, that.delegate); + } + + @Override + public int hashCode() { + int result = ObjectUtils.nullSafeHashCode(this.session); + result = 31 * result + ObjectUtils.nullSafeHashCode(this.delegate); + return result; + } + + public String toString() { + return "SimpleReactiveMongoDatabaseFactory.ClientSessionBoundMongoDbFactory(session=" + this.getSession() + + ", delegate=" + this.getDelegate() + ")"; + } } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexResolver.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexResolver.java index fcaf10567..ac5d22413 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexResolver.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/MongoPersistentEntityIndexResolver.java @@ -15,10 +15,6 @@ */ package org.springframework.data.mongodb.core.index; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.RequiredArgsConstructor; - import java.time.Duration; import java.util.ArrayList; import java.util.Arrays; @@ -33,7 +29,6 @@ import java.util.stream.Collectors; import org.slf4j.Logger; import org.slf4j.LoggerFactory; - import org.springframework.dao.InvalidDataAccessApiUsageException; import org.springframework.data.domain.Sort; import org.springframework.data.mapping.Association; @@ -733,8 +728,6 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver { * @author Christoph Strobl * @author Mark Paluch */ - @RequiredArgsConstructor(access = AccessLevel.PRIVATE) - @EqualsAndHashCode static class Path { private static final Path EMPTY = new Path(Collections.emptyList(), false); @@ -742,6 +735,11 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver { private final List> elements; private final boolean cycle; + private Path(List> elements, boolean cycle) { + this.elements = elements; + this.cycle = cycle; + } + /** * @return an empty {@link Path}. * @since 1.10.8 @@ -843,6 +841,28 @@ public class MongoPersistentEntityIndexResolver implements IndexResolver { return builder.toString(); } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + Path that = (Path) o; + + if (this.cycle != that.cycle) { + return false; + } + return ObjectUtils.nullSafeEquals(this.elements, that.elements); + } + + @Override + public int hashCode() { + int result = ObjectUtils.nullSafeHashCode(elements); + result = 31 * result + (cycle ? 1 : 0); + return result; + } } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/PartialIndexFilter.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/PartialIndexFilter.java index 7cc656d54..66cdf7a80 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/PartialIndexFilter.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/index/PartialIndexFilter.java @@ -16,14 +16,8 @@ package org.springframework.data.mongodb.core.index; import org.bson.Document; - -import lombok.AccessLevel; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import org.springframework.data.mongodb.core.query.CriteriaDefinition; - -import com.mongodb.DBObject; +import org.springframework.util.Assert; /** * {@link IndexFilter} implementation for usage with plain {@link Document} as well as {@link CriteriaDefinition} filter @@ -32,10 +26,16 @@ import com.mongodb.DBObject; * @author Christoph Strobl * @since 1.10 */ -@RequiredArgsConstructor(access = AccessLevel.PRIVATE) public class PartialIndexFilter implements IndexFilter { - private final @NonNull Object filterExpression; + private final Object filterExpression; + + private PartialIndexFilter(Object filterExpression) { + + Assert.notNull(filterExpression, "FilterExpression must not be null!"); + + this.filterExpression = filterExpression; + } /** * Create new {@link PartialIndexFilter} for given {@link Document filter expression}. diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/ChangeStreamTask.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/ChangeStreamTask.java index 81b67c210..668316f2a 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/ChangeStreamTask.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/ChangeStreamTask.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.core.messaging; -import lombok.AllArgsConstructor; - import java.time.Instant; import java.util.Arrays; import java.util.Collections; @@ -217,12 +215,17 @@ class ChangeStreamTask extends CursorReadingTask, * * @since 2.1 */ - @AllArgsConstructor static class ChangeStreamEventMessage implements Message, T> { private final ChangeStreamEvent delegate; private final MessageProperties messageProperties; + ChangeStreamEventMessage(ChangeStreamEvent delegate, MessageProperties messageProperties) { + + this.delegate = delegate; + this.messageProperties = messageProperties; + } + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.messaging.Message#getRaw() diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/DefaultMessageListenerContainer.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/DefaultMessageListenerContainer.java index c9f367614..db84b553b 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/DefaultMessageListenerContainer.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/DefaultMessageListenerContainer.java @@ -15,10 +15,6 @@ */ package org.springframework.data.mongodb.core.messaging; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.RequiredArgsConstructor; - import java.time.Duration; import java.util.LinkedHashMap; import java.util.Map; @@ -34,6 +30,7 @@ import org.springframework.data.mongodb.core.messaging.SubscriptionRequest.Reque import org.springframework.lang.Nullable; import org.springframework.util.Assert; import org.springframework.util.ErrorHandler; +import org.springframework.util.ObjectUtils; /** * Simple {@link Executor} based {@link MessageListenerContainer} implementation for running {@link Task tasks} like @@ -259,7 +256,6 @@ public class DefaultMessageListenerContainer implements MessageListenerContainer * @author Christoph Strobl * @since 2.1 */ - @EqualsAndHashCode static class TaskSubscription implements Subscription { private final Task task; @@ -286,19 +282,39 @@ public class DefaultMessageListenerContainer implements MessageListenerContainer public void cancel() throws DataAccessResourceFailureException { task.cancel(); } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + TaskSubscription that = (TaskSubscription) o; + + return ObjectUtils.nullSafeEquals(this.task, that.task); + } + + @Override + public int hashCode() { + return ObjectUtils.nullSafeHashCode(task); + } } /** * @author Christoph Strobl * @since 2.1 */ - @RequiredArgsConstructor(access = AccessLevel.PACKAGE) private static class DecoratingLoggingErrorHandler implements ErrorHandler { private final Log logger = LogFactory.getLog(DecoratingLoggingErrorHandler.class); private final ErrorHandler delegate; + DecoratingLoggingErrorHandler(ErrorHandler delegate) { + this.delegate = delegate; + } + @Override public void handleError(Throwable t) { diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/LazyMappingDelegatingMessage.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/LazyMappingDelegatingMessage.java index bdcddad85..50c47a679 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/LazyMappingDelegatingMessage.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/LazyMappingDelegatingMessage.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.core.messaging; -import lombok.ToString; - import org.bson.Document; import org.springframework.data.mongodb.core.convert.MongoConverter; import org.springframework.util.ClassUtils; @@ -26,7 +24,6 @@ import org.springframework.util.ClassUtils; * @author Mark Paluch * @since 2.1 */ -@ToString(of = { "delegate", "targetType" }) class LazyMappingDelegatingMessage implements Message { private final Message delegate; @@ -82,4 +79,8 @@ class LazyMappingDelegatingMessage implements Message { public MessageProperties getProperties() { return delegate.getProperties(); } + + public String toString() { + return "LazyMappingDelegatingMessage(delegate=" + this.delegate + ", targetType=" + this.targetType + ")"; + } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/Message.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/Message.java index 13b27f900..2024d0b52 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/Message.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/Message.java @@ -15,11 +15,9 @@ */ package org.springframework.data.mongodb.core.messaging; -import lombok.EqualsAndHashCode; -import lombok.ToString; - import org.springframework.lang.Nullable; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; /** * General message abstraction for any type of Event / Message published by MongoDB server to the client. This might be @@ -65,8 +63,6 @@ public interface Message { * @author Christoph Strobl * @since 2.1 */ - @ToString - @EqualsAndHashCode class MessageProperties { private static final MessageProperties EMPTY = new MessageProperties(); @@ -111,6 +107,34 @@ public interface Message { return new MessagePropertiesBuilder(); } + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + MessageProperties that = (MessageProperties) o; + + if (!ObjectUtils.nullSafeEquals(this.databaseName, that.databaseName)) { + return false; + } + + return ObjectUtils.nullSafeEquals(this.collectionName, that.collectionName); + } + + @Override + public int hashCode() { + int result = ObjectUtils.nullSafeHashCode(databaseName); + result = 31 * result + ObjectUtils.nullSafeHashCode(collectionName); + return result; + } + + public String toString() { + return "Message.MessageProperties(databaseName=" + this.getDatabaseName() + ", collectionName=" + + this.getCollectionName() + ")"; + } + /** * Builder for {@link MessageProperties}. * diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/SimpleMessage.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/SimpleMessage.java index 320ba5ec6..1907e4442 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/SimpleMessage.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/messaging/SimpleMessage.java @@ -15,11 +15,9 @@ */ package org.springframework.data.mongodb.core.messaging; -import lombok.EqualsAndHashCode; -import lombok.ToString; - import org.springframework.lang.Nullable; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; /** * Trivial {@link Message} implementation. @@ -27,8 +25,6 @@ import org.springframework.util.Assert; * @author Christoph Strobl * @since 2.1 */ -@EqualsAndHashCode -@ToString class SimpleMessage implements Message { private @Nullable final S raw; @@ -75,4 +71,35 @@ class SimpleMessage implements Message { public MessageProperties getProperties() { return properties; } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + SimpleMessage that = (SimpleMessage) o; + + if (!ObjectUtils.nullSafeEquals(this.raw, that.raw)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(this.body, that.body)) { + return false; + } + return ObjectUtils.nullSafeEquals(this.properties, that.properties); + } + + @Override + public int hashCode() { + int result = ObjectUtils.nullSafeHashCode(raw); + result = 31 * result + ObjectUtils.nullSafeHashCode(body); + result = 31 * result + ObjectUtils.nullSafeHashCode(properties); + return result; + } + + public String toString() { + return "SimpleMessage(raw=" + this.getRaw() + ", body=" + this.getBody() + ", properties=" + this.getProperties() + + ")"; + } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Collation.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Collation.java index 80428ddf6..191ba34cc 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Collation.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/Collation.java @@ -15,11 +15,6 @@ */ package org.springframework.data.mongodb.core.query; -import lombok.AccessLevel; -import lombok.AllArgsConstructor; -import lombok.Getter; -import lombok.RequiredArgsConstructor; - import java.util.Locale; import java.util.Optional; @@ -515,8 +510,6 @@ public class Collation { * * @since 2.0 */ - @AllArgsConstructor(access = AccessLevel.PACKAGE) - @Getter static class ICUComparisonLevel implements ComparisonLevel { private final int level; @@ -526,6 +519,24 @@ public class Collation { ICUComparisonLevel(int level) { this(level, Optional.empty(), Optional.empty()); } + + ICUComparisonLevel(int level, Optional caseFirst, Optional caseLevel) { + this.level = level; + this.caseFirst = caseFirst; + this.caseLevel = caseLevel; + } + + public int getLevel() { + return this.level; + } + + public Optional getCaseFirst() { + return this.caseFirst; + } + + public Optional getCaseLevel() { + return this.caseLevel; + } } /** @@ -650,7 +661,6 @@ public class Collation { /** * @since 2.0 */ - @RequiredArgsConstructor(access = AccessLevel.PRIVATE) public static class CaseFirst { private static final CaseFirst UPPER = new CaseFirst("upper"); @@ -659,6 +669,10 @@ public class Collation { private final String state; + private CaseFirst(String state) { + this.state = state; + } + /** * Sort uppercase before lowercase. * @@ -690,7 +704,6 @@ public class Collation { /** * @since 2.0 */ - @RequiredArgsConstructor(access = AccessLevel.PACKAGE) public static class Alternate { private static final Alternate NON_IGNORABLE = new Alternate("non-ignorable", Optional.empty()); @@ -698,6 +711,11 @@ public class Collation { final String alternate; final Optional maxVariable; + Alternate(String alternate, Optional maxVariable) { + this.alternate = alternate; + this.maxVariable = maxVariable; + } + /** * Consider Whitespace and punctuation as base characters. * @@ -761,12 +779,17 @@ public class Collation { * @see ICU - International Components for Unicode * @since 2.0 */ - @RequiredArgsConstructor(access = AccessLevel.PRIVATE) public static class CollationLocale { private final String language; private final Optional variant; + private CollationLocale(String language, Optional variant) { + + this.language = language; + this.variant = variant; + } + /** * Create new {@link CollationLocale} for given language. * 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 35b771496..4940a857e 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,8 +15,6 @@ */ package org.springframework.data.mongodb.core.query; -import lombok.EqualsAndHashCode; - import java.util.HashMap; import java.util.Map; import java.util.Map.Entry; @@ -24,6 +22,7 @@ import java.util.Map.Entry; import org.bson.Document; import org.springframework.lang.Nullable; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; /** * @author Thomas Risberg @@ -32,7 +31,6 @@ import org.springframework.util.Assert; * @author Christoph Strobl * @author Mark Paluch */ -@EqualsAndHashCode public class Field { private final Map criteria = new HashMap(); @@ -103,4 +101,40 @@ public class Field { return document; } + + @Override + public boolean equals(Object o) { + + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + Field field = (Field) o; + + if (positionValue != field.positionValue) { + return false; + } + if (!ObjectUtils.nullSafeEquals(criteria, field.criteria)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(slices, field.slices)) { + return false; + } + if (!ObjectUtils.nullSafeEquals(elemMatchs, field.elemMatchs)) { + return false; + } + return ObjectUtils.nullSafeEquals(positionKey, field.positionKey); + } + + @Override + public int hashCode() { + + int result = ObjectUtils.nullSafeHashCode(criteria); + result = 31 * result + ObjectUtils.nullSafeHashCode(slices); + result = 31 * result + ObjectUtils.nullSafeHashCode(elemMatchs); + result = 31 * result + ObjectUtils.nullSafeHashCode(positionKey); + result = 31 * result + positionValue; + return result; + } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/UntypedExampleMatcher.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/UntypedExampleMatcher.java index 5701b276d..e75b19406 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/UntypedExampleMatcher.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/query/UntypedExampleMatcher.java @@ -15,14 +15,10 @@ */ package org.springframework.data.mongodb.core.query; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import java.util.Set; import org.springframework.data.domain.ExampleMatcher; +import org.springframework.util.ObjectUtils; /** * {@link ExampleMatcher} implementation for query by example (QBE). Unlike plain {@link ExampleMatcher} this untyped @@ -33,11 +29,13 @@ import org.springframework.data.domain.ExampleMatcher; * @author Mark Paluch * @since 2.0 */ -@EqualsAndHashCode -@RequiredArgsConstructor(access = AccessLevel.PRIVATE) public class UntypedExampleMatcher implements ExampleMatcher { - private final @NonNull ExampleMatcher delegate; + private final ExampleMatcher delegate; + + private UntypedExampleMatcher(ExampleMatcher delegate) { + this.delegate = delegate; + } /* * (non-Javadoc) @@ -224,4 +222,22 @@ public class UntypedExampleMatcher implements ExampleMatcher { return delegate.getMatchMode(); } + @Override + public boolean equals(Object o) { + + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + UntypedExampleMatcher that = (UntypedExampleMatcher) o; + + return ObjectUtils.nullSafeEquals(delegate, that.delegate); + } + + @Override + public int hashCode() { + + return ObjectUtils.nullSafeHashCode(delegate); + } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/DefaultMongoJsonSchema.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/DefaultMongoJsonSchema.java index cff333b76..1c736fcda 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/DefaultMongoJsonSchema.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/DefaultMongoJsonSchema.java @@ -15,10 +15,8 @@ */ package org.springframework.data.mongodb.core.schema; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import org.bson.Document; +import org.springframework.util.Assert; /** * Value object representing a MongoDB-specific JSON schema which is the default {@link MongoJsonSchema} implementation. @@ -27,10 +25,15 @@ import org.bson.Document; * @author Mark Paluch * @since 2.1 */ -@AllArgsConstructor class DefaultMongoJsonSchema implements MongoJsonSchema { - private final @NonNull JsonSchemaObject root; + private final JsonSchemaObject root; + + DefaultMongoJsonSchema(JsonSchemaObject root) { + + Assert.notNull(root, "Root must not be null!"); + this.root = root; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/DocumentJsonSchema.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/DocumentJsonSchema.java index 18aa0b355..15a9c5aa1 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/DocumentJsonSchema.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/DocumentJsonSchema.java @@ -15,10 +15,8 @@ */ package org.springframework.data.mongodb.core.schema; -import lombok.AllArgsConstructor; -import lombok.NonNull; - import org.bson.Document; +import org.springframework.util.Assert; /** * JSON schema backed by a {@link org.bson.Document} object. @@ -26,10 +24,15 @@ import org.bson.Document; * @author Mark Paluch * @since 2.1 */ -@AllArgsConstructor class DocumentJsonSchema implements MongoJsonSchema { - private final @NonNull Document document; + private final Document document; + + DocumentJsonSchema(Document document) { + + Assert.notNull(document, "Document must not be null!"); + this.document = document; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/JsonSchemaObject.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/JsonSchemaObject.java index 6ea9c0649..c56497985 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/JsonSchemaObject.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/JsonSchemaObject.java @@ -15,9 +15,6 @@ */ package org.springframework.data.mongodb.core.schema; -import lombok.EqualsAndHashCode; -import lombok.RequiredArgsConstructor; - import java.math.BigDecimal; import java.util.Arrays; import java.util.Collection; @@ -44,6 +41,7 @@ import org.springframework.data.mongodb.core.schema.TypedJsonSchemaObject.String import org.springframework.data.mongodb.core.schema.TypedJsonSchemaObject.TimestampJsonSchemaObject; import org.springframework.lang.Nullable; import org.springframework.util.ClassUtils; +import org.springframework.util.ObjectUtils; /** * Interface that can be implemented by objects that know how to serialize themselves to JSON schema using @@ -500,12 +498,14 @@ public interface JsonSchemaObject { * @author Christpoh Strobl * @since 2.1 */ - @RequiredArgsConstructor - @EqualsAndHashCode class JsonType implements Type { private final String name; + public JsonType(String name) { + this.name = name; + } + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.schema.JsonSchemaObject.Type#representation() @@ -523,18 +523,37 @@ public interface JsonSchemaObject { public String value() { return name; } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + JsonType jsonType = (JsonType) o; + + return ObjectUtils.nullSafeEquals(name, jsonType.name); + } + + @Override + public int hashCode() { + return ObjectUtils.nullSafeHashCode(name); + } } /** * @author Christpoh Strobl * @since 2.1 */ - @RequiredArgsConstructor - @EqualsAndHashCode class BsonType implements Type { private final String name; + BsonType(String name) { + this.name = name; + } + /* * (non-Javadoc) * @see org.springframework.data.mongodb.core.schema.JsonSchemaObject.Type#representation() @@ -552,6 +571,24 @@ public interface JsonSchemaObject { public String value() { return name; } + + @Override + public boolean equals(Object o) { + + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + BsonType bsonType = (BsonType) o; + + return ObjectUtils.nullSafeEquals(name, bsonType.name); + } + + @Override + public int hashCode() { + return ObjectUtils.nullSafeHashCode(name); + } } } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/JsonSchemaProperty.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/JsonSchemaProperty.java index 3d3c2f459..68f0f94c4 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/JsonSchemaProperty.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/JsonSchemaProperty.java @@ -15,9 +15,6 @@ */ package org.springframework.data.mongodb.core.schema; -import lombok.AccessLevel; -import lombok.RequiredArgsConstructor; - import org.springframework.data.mongodb.core.schema.TypedJsonSchemaObject.NumericJsonSchemaObject; import org.springframework.data.mongodb.core.schema.TypedJsonSchemaObject.ObjectJsonSchemaObject; import org.springframework.data.mongodb.core.schema.IdentifiableJsonSchemaProperty.*; @@ -239,11 +236,14 @@ public interface JsonSchemaProperty extends JsonSchemaObject { /** * Builder for {@link IdentifiableJsonSchemaProperty}. */ - @RequiredArgsConstructor(access = AccessLevel.PACKAGE) class JsonSchemaPropertyBuilder { private final String identifier; + JsonSchemaPropertyBuilder(String identifier) { + this.identifier = identifier; + } + /** * Configure a {@link Type} for the property. * diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/UntypedJsonSchemaObject.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/UntypedJsonSchemaObject.java index d1f695428..ea475ef72 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/UntypedJsonSchemaObject.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/schema/UntypedJsonSchemaObject.java @@ -15,9 +15,6 @@ */ package org.springframework.data.mongodb.core.schema; -import lombok.AccessLevel; -import lombok.RequiredArgsConstructor; - import java.util.Collection; import java.util.Collections; import java.util.List; @@ -182,7 +179,6 @@ public class UntypedJsonSchemaObject implements JsonSchemaObject { * @author Christoph Strobl * @since 2.1 */ - @RequiredArgsConstructor(access = AccessLevel.PACKAGE) static class Restrictions { private final Collection possibleValues; @@ -191,6 +187,16 @@ public class UntypedJsonSchemaObject implements JsonSchemaObject { private final Collection oneOf; private final @Nullable JsonSchemaObject notMatch; + Restrictions(Collection possibleValues, Collection allOf, + Collection anyOf, Collection oneOf, JsonSchemaObject notMatch) { + + this.possibleValues = possibleValues; + this.allOf = allOf; + this.anyOf = anyOf; + this.oneOf = oneOf; + this.notMatch = notMatch; + } + /** * @return new empty {@link Restrictions}. */ diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/CriteriaValidator.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/CriteriaValidator.java index fa76e1d47..6e20aae77 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/CriteriaValidator.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/CriteriaValidator.java @@ -15,15 +15,12 @@ */ package org.springframework.data.mongodb.core.validation; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.RequiredArgsConstructor; - import org.bson.Document; import org.springframework.data.mongodb.core.query.Criteria; import org.springframework.data.mongodb.core.query.CriteriaDefinition; import org.springframework.data.mongodb.core.query.SerializationUtils; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; /** * {@link Validator} implementation based on {@link CriteriaDefinition query expressions}. @@ -34,12 +31,14 @@ import org.springframework.util.Assert; * @see Criteria * @see Schema Validation */ -@RequiredArgsConstructor(access = AccessLevel.PRIVATE) -@EqualsAndHashCode class CriteriaValidator implements Validator { private final CriteriaDefinition criteria; + private CriteriaValidator(CriteriaDefinition criteria) { + this.criteria = criteria; + } + /** * Creates a new {@link Validator} object, which is basically setup of query operators, based on a * {@link CriteriaDefinition} instance. @@ -72,4 +71,21 @@ class CriteriaValidator implements Validator { public String toString() { return SerializationUtils.serializeToJsonSafely(toDocument()); } + + @Override + public boolean equals(Object o) { + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + CriteriaValidator that = (CriteriaValidator) o; + + return ObjectUtils.nullSafeEquals(criteria, that.criteria); + } + + @Override + public int hashCode() { + return ObjectUtils.nullSafeHashCode(criteria); + } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/DocumentValidator.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/DocumentValidator.java index aff192029..74f75b3e3 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/DocumentValidator.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/DocumentValidator.java @@ -15,13 +15,10 @@ */ package org.springframework.data.mongodb.core.validation; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.RequiredArgsConstructor; - import org.bson.Document; import org.springframework.data.mongodb.core.query.SerializationUtils; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; /** * Most trivial {@link Validator} implementation using plain {@link Document} to describe the desired document structure @@ -32,12 +29,14 @@ import org.springframework.util.Assert; * @since 2.1 * @see Schema Validation */ -@RequiredArgsConstructor(access = AccessLevel.PRIVATE) -@EqualsAndHashCode class DocumentValidator implements Validator { private final Document validatorObject; + private DocumentValidator(Document validatorObject) { + this.validatorObject = validatorObject; + } + /** * Create new {@link DocumentValidator} defining validation rules via a plain {@link Document}. * @@ -68,4 +67,22 @@ class DocumentValidator implements Validator { public String toString() { return SerializationUtils.serializeToJsonSafely(validatorObject); } + + @Override + public boolean equals(Object o) { + + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + DocumentValidator that = (DocumentValidator) o; + + return ObjectUtils.nullSafeEquals(validatorObject, that.validatorObject); + } + + @Override + public int hashCode() { + return ObjectUtils.nullSafeHashCode(validatorObject); + } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/JsonSchemaValidator.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/JsonSchemaValidator.java index 80bb6de70..01f766892 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/JsonSchemaValidator.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/validation/JsonSchemaValidator.java @@ -15,14 +15,11 @@ */ package org.springframework.data.mongodb.core.validation; -import lombok.AccessLevel; -import lombok.EqualsAndHashCode; -import lombok.RequiredArgsConstructor; - import org.bson.Document; import org.springframework.data.mongodb.core.query.SerializationUtils; import org.springframework.data.mongodb.core.schema.MongoJsonSchema; import org.springframework.util.Assert; +import org.springframework.util.ObjectUtils; /** * {@link Validator} implementation based on {@link MongoJsonSchema JSON Schema}. @@ -32,12 +29,14 @@ import org.springframework.util.Assert; * @since 2.1 * @see Schema Validation */ -@RequiredArgsConstructor(access = AccessLevel.PRIVATE) -@EqualsAndHashCode class JsonSchemaValidator implements Validator { private final MongoJsonSchema schema; + private JsonSchemaValidator(MongoJsonSchema schema) { + this.schema = schema; + } + /** * Create new {@link JsonSchemaValidator} defining validation rules via {@link MongoJsonSchema}. * @@ -68,4 +67,22 @@ class JsonSchemaValidator implements Validator { public String toString() { return SerializationUtils.serializeToJsonSafely(toDocument()); } + + @Override + public boolean equals(Object o) { + + if (this == o) + return true; + if (o == null || getClass() != o.getClass()) + return false; + + JsonSchemaValidator that = (JsonSchemaValidator) o; + + return ObjectUtils.nullSafeEquals(schema, that.schema); + } + + @Override + public int hashCode() { + return ObjectUtils.nullSafeHashCode(schema); + } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/AggregationUtils.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/AggregationUtils.java index e78cb6504..970fcbbdb 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/AggregationUtils.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/AggregationUtils.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.repository.query; -import lombok.experimental.UtilityClass; - import java.time.Duration; import java.util.ArrayList; import java.util.List; @@ -49,11 +47,14 @@ import org.springframework.util.StringUtils; * @author Mark Paluch * @since 2.2 */ -@UtilityClass -class AggregationUtils { +final class AggregationUtils { private static final ParameterBindingDocumentCodec CODEC = new ParameterBindingDocumentCodec(); + private AggregationUtils() { + throw new UnsupportedOperationException("This is a utility class and cannot be instantiated"); + } + /** * Apply a collation extracted from the given {@literal collationExpression} to the given * {@link org.springframework.data.mongodb.core.aggregation.AggregationOptions.Builder}. Potentially replace parameter diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/BooleanUtil.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/BooleanUtil.java index e07a85e1d..b2e660ab7 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/BooleanUtil.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/BooleanUtil.java @@ -15,16 +15,17 @@ */ package org.springframework.data.mongodb.repository.query; -import lombok.experimental.UtilityClass; - /** * Utility class containing methods to interact with boolean values. * * @author Mark Paluch * @since 2.0.9 */ -@UtilityClass -class BooleanUtil { +final class BooleanUtil { + + private BooleanUtil() { + throw new UnsupportedOperationException("This is a utility class and cannot be instantiated"); + } /** * Count the number of {@literal true} values. diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/CollationUtils.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/CollationUtils.java index 411674e26..7302f3056 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/CollationUtils.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/CollationUtils.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.repository.query; -import lombok.experimental.UtilityClass; - import java.util.Locale; import java.util.regex.Matcher; import java.util.regex.Pattern; @@ -39,12 +37,15 @@ import org.springframework.util.StringUtils; * @author Christoph Strobl * @since 2.2 */ -@UtilityClass -class CollationUtils { +final class CollationUtils { private static final ParameterBindingDocumentCodec CODEC = new ParameterBindingDocumentCodec(); private static final Pattern PARAMETER_BINDING_PATTERN = Pattern.compile("\\?(\\d+)"); + private CollationUtils() { + throw new UnsupportedOperationException("This is a utility class and cannot be instantiated"); + } + /** * Compute the {@link Collation} by inspecting the {@link ConvertingParameterAccessor#getCollation() parameter * accessor} or parsing a potentially given {@literal collationExpression}. diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoQueryExecution.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoQueryExecution.java index 3b5db0691..facc461f5 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoQueryExecution.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/MongoQueryExecution.java @@ -15,9 +15,6 @@ */ package org.springframework.data.mongodb.repository.query; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; - import java.util.List; import org.springframework.data.domain.Page; @@ -30,6 +27,7 @@ import org.springframework.data.geo.GeoPage; import org.springframework.data.geo.GeoResult; import org.springframework.data.geo.GeoResults; import org.springframework.data.geo.Point; +import org.springframework.data.mongodb.core.ExecutableFindOperation; import org.springframework.data.mongodb.core.ExecutableFindOperation.FindWithQuery; import org.springframework.data.mongodb.core.ExecutableFindOperation.TerminatingFind; import org.springframework.data.mongodb.core.MongoOperations; @@ -37,6 +35,7 @@ import org.springframework.data.mongodb.core.query.NearQuery; import org.springframework.data.mongodb.core.query.Query; import org.springframework.data.repository.support.PageableExecutionUtils; import org.springframework.data.util.TypeInformation; +import org.springframework.util.Assert; import org.springframework.util.ClassUtils; import com.mongodb.client.result.DeleteResult; @@ -62,11 +61,19 @@ interface MongoQueryExecution { * @author Christoph Strobl * @since 1.5 */ - @RequiredArgsConstructor final class SlicedExecution implements MongoQueryExecution { - private final @NonNull FindWithQuery find; - private final @NonNull Pageable pageable; + private final FindWithQuery find; + private final Pageable pageable; + + public SlicedExecution(ExecutableFindOperation.FindWithQuery find, Pageable pageable) { + + Assert.notNull(find, "Find must not be null!"); + Assert.notNull(pageable, "Pageable must not be null!"); + + this.find = find; + this.pageable = pageable; + } /* * (non-Javadoc) @@ -95,11 +102,19 @@ interface MongoQueryExecution { * @author Mark Paluch * @author Christoph Strobl */ - @RequiredArgsConstructor final class PagedExecution implements MongoQueryExecution { - private final @NonNull FindWithQuery operation; - private final @NonNull Pageable pageable; + private final FindWithQuery operation; + private final Pageable pageable; + + public PagedExecution(ExecutableFindOperation.FindWithQuery operation, Pageable pageable) { + + Assert.notNull(operation, "Operation must not be null!"); + Assert.notNull(pageable, "Pageable must not be null!"); + + this.operation = operation; + this.pageable = pageable; + } /* * (non-Javadoc) @@ -133,12 +148,23 @@ interface MongoQueryExecution { * * @author Oliver Gierke */ - @RequiredArgsConstructor class GeoNearExecution implements MongoQueryExecution { - private final @NonNull FindWithQuery operation; - private final @NonNull MongoQueryMethod method; - private final @NonNull MongoParameterAccessor accessor; + private final FindWithQuery operation; + private final MongoQueryMethod method; + private final MongoParameterAccessor accessor; + + public GeoNearExecution(ExecutableFindOperation.FindWithQuery operation, MongoQueryMethod method, + MongoParameterAccessor accessor) { + + Assert.notNull(operation, "Operation must not be null!"); + Assert.notNull(method, "Method must not be null!"); + Assert.notNull(accessor, "Accessor must not be null!"); + + this.operation = operation; + this.method = method; + this.accessor = accessor; + } /* * (non-Javadoc) @@ -236,11 +262,19 @@ interface MongoQueryExecution { * @author Christoph Strobl * @since 1.5 */ - @RequiredArgsConstructor final class DeleteExecution implements MongoQueryExecution { - private final @NonNull MongoOperations operations; - private final @NonNull MongoQueryMethod method; + private final MongoOperations operations; + private final MongoQueryMethod method; + + public DeleteExecution(MongoOperations operations, MongoQueryMethod method) { + + Assert.notNull(operations, "Operations must not be null!"); + Assert.notNull(method, "Method must not be null!"); + + this.operations = operations; + this.method = method; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryExecution.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryExecution.java index 9feb4a9d9..e2b9d51da 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryExecution.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/ReactiveMongoQueryExecution.java @@ -15,13 +15,10 @@ */ package org.springframework.data.mongodb.repository.query; -import lombok.NonNull; -import lombok.RequiredArgsConstructor; import reactor.core.publisher.Flux; import reactor.core.publisher.Mono; import org.reactivestreams.Publisher; - import org.springframework.core.convert.converter.Converter; import org.springframework.data.domain.Pageable; import org.springframework.data.domain.Range; @@ -37,6 +34,7 @@ import org.springframework.data.repository.query.ReturnedType; import org.springframework.data.repository.util.ReactiveWrappers; import org.springframework.data.util.TypeInformation; import org.springframework.lang.Nullable; +import org.springframework.util.Assert; import org.springframework.util.ClassUtils; /** @@ -57,13 +55,20 @@ interface ReactiveMongoQueryExecution { * * @author Mark Paluch */ - @RequiredArgsConstructor class GeoNearExecution implements ReactiveMongoQueryExecution { private final ReactiveMongoOperations operations; private final MongoParameterAccessor accessor; private final TypeInformation returnType; + public GeoNearExecution(ReactiveMongoOperations operations, MongoParameterAccessor accessor, + TypeInformation returnType) { + + this.operations = operations; + this.accessor = accessor; + this.returnType = returnType; + } + /* * (non-Javadoc) * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String) @@ -112,12 +117,16 @@ interface ReactiveMongoQueryExecution { * @author Mark Paluch * @author Artyom Gabeev */ - @RequiredArgsConstructor final class DeleteExecution implements ReactiveMongoQueryExecution { private final ReactiveMongoOperations operations; private final MongoQueryMethod method; + public DeleteExecution(ReactiveMongoOperations operations, MongoQueryMethod method) { + this.operations = operations; + this.method = method; + } + /* * (non-Javadoc) * @see org.springframework.data.mongodb.repository.query.AbstractMongoQuery.Execution#execute(org.springframework.data.mongodb.core.query.Query, java.lang.Class, java.lang.String) @@ -142,11 +151,19 @@ interface ReactiveMongoQueryExecution { * An {@link ReactiveMongoQueryExecution} that wraps the results of the given delegate with the given result * processing. */ - @RequiredArgsConstructor final class ResultProcessingExecution implements ReactiveMongoQueryExecution { - private final @NonNull ReactiveMongoQueryExecution delegate; - private final @NonNull Converter converter; + private final ReactiveMongoQueryExecution delegate; + private final Converter converter; + + public ResultProcessingExecution(ReactiveMongoQueryExecution delegate, Converter converter) { + + Assert.notNull(delegate, "Delegate must not be null!"); + Assert.notNull(converter, "Converter must not be null!"); + + this.delegate = delegate; + this.converter = converter; + } @Override public Object execute(Query query, Class type, String collection) { @@ -159,12 +176,23 @@ interface ReactiveMongoQueryExecution { * * @author Mark Paluch */ - @RequiredArgsConstructor final class ResultProcessingConverter implements Converter { - private final @NonNull ResultProcessor processor; - private final @NonNull ReactiveMongoOperations operations; - private final @NonNull EntityInstantiators instantiators; + private final ResultProcessor processor; + private final ReactiveMongoOperations operations; + private final EntityInstantiators instantiators; + + public ResultProcessingConverter(ResultProcessor processor, ReactiveMongoOperations operations, + EntityInstantiators instantiators) { + + Assert.notNull(processor, "Processor must not be null!"); + Assert.notNull(operations, "Operations must not be null!"); + Assert.notNull(instantiators, "Instantiators must not be null!"); + + this.processor = processor; + this.operations = operations; + this.instantiators = instantiators; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/SimpleMongoEntityMetadata.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/SimpleMongoEntityMetadata.java index 09a5892e5..48d35a104 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/SimpleMongoEntityMetadata.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/repository/query/SimpleMongoEntityMetadata.java @@ -15,8 +15,6 @@ */ package org.springframework.data.mongodb.repository.query; -import lombok.Getter; - import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity; import org.springframework.util.Assert; @@ -28,7 +26,7 @@ import org.springframework.util.Assert; class SimpleMongoEntityMetadata implements MongoEntityMetadata { private final Class type; - private final @Getter MongoPersistentEntity collectionEntity; + private final MongoPersistentEntity collectionEntity; /** * Creates a new {@link SimpleMongoEntityMetadata} using the given type and {@link MongoPersistentEntity} to use for @@ -61,4 +59,8 @@ class SimpleMongoEntityMetadata implements MongoEntityMetadata { public String getCollectionName() { return collectionEntity.getCollection(); } + + public MongoPersistentEntity getCollectionEntity() { + return this.collectionEntity; + } } 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 dfbf7acbb..d6508e8a4 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 @@ -17,9 +17,6 @@ package org.springframework.data.mongodb.repository.support; import static org.springframework.data.querydsl.QuerydslUtils.*; -import lombok.AccessLevel; -import lombok.RequiredArgsConstructor; - import java.io.Serializable; import java.lang.reflect.Method; import java.util.Optional; @@ -157,13 +154,21 @@ public class ReactiveMongoRepositoryFactory extends ReactiveRepositoryFactorySup * @author Mark Paluch * @author Christoph Strobl */ - @RequiredArgsConstructor(access = AccessLevel.PACKAGE) private static class MongoQueryLookupStrategy implements QueryLookupStrategy { private final ReactiveMongoOperations operations; private final QueryMethodEvaluationContextProvider evaluationContextProvider; private final MappingContext, MongoPersistentProperty> mappingContext; + MongoQueryLookupStrategy(ReactiveMongoOperations operations, + QueryMethodEvaluationContextProvider evaluationContextProvider, + MappingContext, MongoPersistentProperty> mappingContext) { + + this.operations = operations; + this.evaluationContextProvider = evaluationContextProvider; + this.mappingContext = mappingContext; + } + /* * (non-Javadoc) * @see org.springframework.data.repository.query.QueryLookupStrategy#resolveQuery(java.lang.reflect.Method, org.springframework.data.repository.core.RepositoryMetadata, org.springframework.data.projection.ProjectionFactory, org.springframework.data.repository.core.NamedQueries) 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 23f9ba65e..0a1b05db3 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,8 +17,6 @@ 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; @@ -51,11 +49,20 @@ import com.mongodb.client.result.DeleteResult; * @author Ruben J Garcia * @since 2.0 */ -@RequiredArgsConstructor public class SimpleReactiveMongoRepository implements ReactiveMongoRepository { - private final @NonNull MongoEntityInformation entityInformation; - private final @NonNull ReactiveMongoOperations mongoOperations; + private final MongoEntityInformation entityInformation; + private final ReactiveMongoOperations mongoOperations; + + public SimpleReactiveMongoRepository(MongoEntityInformation entityInformation, + ReactiveMongoOperations mongoOperations) { + + Assert.notNull(entityInformation, "EntityInformation must not be null!"); + Assert.notNull(mongoOperations, "MongoOperations must not be null!"); + + this.entityInformation = entityInformation; + this.mongoOperations = mongoOperations; + } /* * (non-Javadoc) diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/util/json/ParameterBindingJsonReader.java b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/util/json/ParameterBindingJsonReader.java index 140208151..2cf11d8d1 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/util/json/ParameterBindingJsonReader.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/mongodb/util/json/ParameterBindingJsonReader.java @@ -17,8 +17,6 @@ package org.springframework.data.mongodb.util.json; import static java.lang.String.*; -import lombok.Data; - import java.text.DateFormat; import java.text.ParsePosition; import java.text.SimpleDateFormat; @@ -1631,12 +1629,37 @@ public class ParameterBindingJsonReader extends AbstractBsonReader { // Spring Data Customization START - @Data static class BindableValue { - BsonType type; - Object value; - int index; + private BsonType type; + private Object value; + private int index; + + BindableValue() {} + + BsonType getType() { + return type; + } + + void setType(BsonType type) { + this.type = type; + } + + Object getValue() { + return value; + } + + void setValue(Object value) { + this.value = value; + } + + int getIndex() { + return index; + } + + void setIndex(int index) { + this.index = index; + } } // Spring Data Customization END