DATAMONGO-1609 - Hacking.

Author: odrotbohm

pom.xml

@@ -31,6 +31,7 @@
 		<springdata.commons>2.0.0.BUILD-SNAPSHOT</springdata.commons>
 		<mongo>3.2.2</mongo>
 		<mongo.reactivestreams>1.2.0</mongo.reactivestreams>
+		<mockito>2.2.17</mockito>
 	</properties>
 
 	<developers>

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/MongoTemplate.java

@@ -24,6 +24,7 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
@@ -43,7 +44,6 @@
 import org.springframework.data.convert.WritingConverter;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.data.mongodb.core.mapping.MongoSimpleTypes;
-import org.springframework.data.util.CacheValue;
 import org.springframework.util.Assert;
 
 /**
@@ -71,9 +71,9 @@ public class CustomConversions {
 
 	private final List<Object> converters;
 
-	private final Map<ConvertiblePair, CacheValue<Class<?>>> customReadTargetTypes;
-	private final Map<ConvertiblePair, CacheValue<Class<?>>> customWriteTargetTypes;
-	private final Map<Class<?>, CacheValue<Class<?>>> rawWriteTargetTypes;
+	private final Map<ConvertiblePair, Optional<Class<?>>> customReadTargetTypes;
+	private final Map<ConvertiblePair, Optional<Class<?>>> customWriteTargetTypes;
+	private final Map<Class<?>, Optional<Class<?>>> rawWriteTargetTypes;
 
 	/**
 	 * Creates an empty {@link CustomConversions} object.
@@ -91,12 +91,12 @@ public CustomConversions(List<?> converters) {
 
 		Assert.notNull(converters, "List of converters must not be null!");
 
-		this.readingPairs = new LinkedHashSet<ConvertiblePair>();
-		this.writingPairs = new LinkedHashSet<ConvertiblePair>();
-		this.customSimpleTypes = new HashSet<Class<?>>();
-		this.customReadTargetTypes = new ConcurrentHashMap<ConvertiblePair, CacheValue<Class<?>>>();
-		this.customWriteTargetTypes = new ConcurrentHashMap<ConvertiblePair, CacheValue<Class<?>>>();
-		this.rawWriteTargetTypes = new ConcurrentHashMap<Class<?>, CacheValue<Class<?>>>();
+		this.readingPairs = new LinkedHashSet<>();
+		this.writingPairs = new LinkedHashSet<>();
+		this.customSimpleTypes = new HashSet<>();
+		this.customReadTargetTypes = new ConcurrentHashMap<>();
+		this.customWriteTargetTypes = new ConcurrentHashMap<>();
+		this.rawWriteTargetTypes = new ConcurrentHashMap<>();
 
 		List<Object> toRegister = new ArrayList<Object>();
 
@@ -241,13 +241,8 @@ private void register(ConverterRegistration converterRegistration) {
 	 */
 	public Class<?> getCustomWriteTarget(final Class<?> sourceType) {
 
-		return getOrCreateAndCache(sourceType, rawWriteTargetTypes, new Producer() {
-
-			@Override
-			public Class<?> get() {
-				return getCustomTarget(sourceType, null, writingPairs);
-			}
-		});
+		return rawWriteTargetTypes.computeIfAbsent(sourceType, it -> getCustomTarget(sourceType, null, writingPairs))
+				.orElse(null);
 	}
 
 	/**
@@ -265,14 +260,8 @@ public Class<?> getCustomWriteTarget(final Class<?> sourceType, final Class<?> r
 			return getCustomWriteTarget(sourceType);
 		}
 
-		return getOrCreateAndCache(new ConvertiblePair(sourceType, requestedTargetType), customWriteTargetTypes,
-				new Producer() {
-
-					@Override
-					public Class<?> get() {
-						return getCustomTarget(sourceType, requestedTargetType, writingPairs);
-					}
-				});
+		return customWriteTargetTypes.computeIfAbsent(new ConvertiblePair(sourceType, requestedTargetType),
+				it -> getCustomTarget(sourceType, requestedTargetType, writingPairs)).orElse(null);
 	}
 
 	/**
@@ -324,14 +313,8 @@ private Class<?> getCustomReadTarget(final Class<?> sourceType, final Class<?> r
 			return null;
 		}
 
-		return getOrCreateAndCache(new ConvertiblePair(sourceType, requestedTargetType), customReadTargetTypes,
-				new Producer() {
-
-					@Override
-					public Class<?> get() {
-						return getCustomTarget(sourceType, requestedTargetType, readingPairs);
-					}
-				});
+		return customReadTargetTypes.computeIfAbsent(new ConvertiblePair(sourceType, requestedTargetType),
+				it -> getCustomTarget(sourceType, requestedTargetType, readingPairs)).orElse(null);
 	}
 
 	/**
@@ -343,54 +326,26 @@ public Class<?> get() {
 	 * @param pairs must not be {@literal null}.
 	 * @return
 	 */
-	private static Class<?> getCustomTarget(Class<?> sourceType, Class<?> requestedTargetType,
+	private static Optional<Class<?>> getCustomTarget(Class<?> sourceType, Class<?> requestedTargetType,
 			Collection<ConvertiblePair> pairs) {
 
 		Assert.notNull(sourceType, "Source Class must not be null!");
 		Assert.notNull(pairs, "Collection of ConvertiblePair must not be null!");
 
 		if (requestedTargetType != null && pairs.contains(new ConvertiblePair(sourceType, requestedTargetType))) {
-			return requestedTargetType;
+			return Optional.of(requestedTargetType);
 		}
 
 		for (ConvertiblePair typePair : pairs) {
 			if (typePair.getSourceType().isAssignableFrom(sourceType)) {
 				Class<?> targetType = typePair.getTargetType();
 				if (requestedTargetType == null || targetType.isAssignableFrom(requestedTargetType)) {
-					return targetType;
+					return Optional.of(targetType);
 				}
 			}
 		}
 
-		return null;
-	}
-
-	/**
-	 * Will try to find a value for the given key in the given cache or produce one using the given {@link Producer} and
-	 * store it in the cache.
-	 * 
-	 * @param key the key to lookup a potentially existing value, must not be {@literal null}.
-	 * @param cache the cache to find the value in, must not be {@literal null}.
-	 * @param producer the {@link Producer} to create values to cache, must not be {@literal null}.
-	 * @return
-	 */
-	private static <T> Class<?> getOrCreateAndCache(T key, Map<T, CacheValue<Class<?>>> cache, Producer producer) {
-
-		CacheValue<Class<?>> cacheValue = cache.get(key);
-
-		if (cacheValue != null) {
-			return cacheValue.getValue();
-		}
-
-		Class<?> type = producer.get();
-		cache.put(key, CacheValue.<Class<?>> ofNullable(type));
-
-		return type;
-	}
-
-	private interface Producer {
-
-		Class<?> get();
+		return Optional.empty();
 	}
 
 	@WritingConverter

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/CustomConversions.java

@@ -17,6 +17,7 @@
 
 import org.bson.Document;
 import java.util.List;
+import java.util.Optional;
 
 import org.springframework.dao.InvalidDataAccessApiUsageException;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
@@ -45,7 +46,7 @@ public interface DbRefResolver {
 	 * @param callback will never be {@literal null}.
 	 * @return
 	 */
-	Object resolveDbRef(MongoPersistentProperty property, DBRef dbref, DbRefResolverCallback callback,
+	Optional<Object> resolveDbRef(MongoPersistentProperty property, DBRef dbref, DbRefResolverCallback callback,
 			DbRefProxyHandler proxyHandler);
 
 	/**

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/DbRefResolver.java

@@ -61,8 +61,9 @@ public Object populateId(MongoPersistentProperty property, DBRef source, Object
 			return proxy;
 		}
 
-		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(property);
-		MongoPersistentProperty idProperty = entity.getIdProperty();
+		MongoPersistentEntity<?> entity = mappingContext.getRequiredPersistentEntity(property);
+		MongoPersistentProperty idProperty = entity.getIdProperty()
+				.orElseThrow(() -> new IllegalStateException("Couldn't find identifier property!"));
 
 		if (idProperty.usePropertyAccess()) {
 			return proxy;

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/DefaultDbRefProxyHandler.java

@@ -26,6 +26,7 @@
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.List;
+import java.util.Optional;
 
 import org.aopalliance.intercept.MethodInterceptor;
 import org.aopalliance.intercept.MethodInvocation;
@@ -84,17 +85,17 @@ public DefaultDbRefResolver(MongoDbFactory mongoDbFactory) {
 	 * @see org.springframework.data.mongodb.core.convert.DbRefResolver#resolveDbRef(org.springframework.data.mongodb.core.mapping.MongoPersistentProperty, org.springframework.data.mongodb.core.convert.DbRefResolverCallback)
 	 */
 	@Override
-	public Object resolveDbRef(MongoPersistentProperty property, DBRef dbref, DbRefResolverCallback callback,
+	public Optional<Object> resolveDbRef(MongoPersistentProperty property, DBRef dbref, DbRefResolverCallback callback,
 			DbRefProxyHandler handler) {
 
 		Assert.notNull(property, "Property must not be null!");
 		Assert.notNull(callback, "Callback must not be null!");
 
 		if (isLazyDbRef(property)) {
-			return createLazyLoadingProxy(property, dbref, callback, handler);
+			return Optional.of(createLazyLoadingProxy(property, dbref, callback, handler));
 		}
 
-		return callback.resolve(property);
+		return Optional.ofNullable(callback.resolve(property));
 	}
 
 	/* 

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/DefaultDbRefResolver.java

@@ -18,6 +18,7 @@
 import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 
 import org.bson.Document;
@@ -26,6 +27,7 @@
 import org.springframework.data.convert.SimpleTypeInformationMapper;
 import org.springframework.data.convert.TypeAliasAccessor;
 import org.springframework.data.convert.TypeInformationMapper;
+import org.springframework.data.mapping.Alias;
 import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.util.ClassTypeInformation;
@@ -116,13 +118,13 @@ public void writeTypeRestrictions(Document result, Set<Class<?>> restrictedTypes
 		accessor.writeTypeTo(result, new Document("$in", restrictedMappedTypes));
 	}
 
-	/* (non-Javadoc)
+	/* 
+	 * (non-Javadoc)
 	 * @see org.springframework.data.convert.DefaultTypeMapper#getFallbackTypeFor(java.lang.Object)
 	 */
 	@Override
-	protected TypeInformation<?> getFallbackTypeFor(Bson source) {
-
-		return source instanceof BasicDBList ? LIST_TYPE_INFO : MAP_TYPE_INFO;
+	protected Optional<TypeInformation<?>> getFallbackTypeFor(Bson source) {
+		return Optional.of(source instanceof BasicDBList ? LIST_TYPE_INFO : MAP_TYPE_INFO);
 	}
 
 	/**
@@ -142,16 +144,16 @@ public DocumentTypeAliasAccessor(String typeKey) {
 		 * (non-Javadoc)
 		 * @see org.springframework.data.convert.TypeAliasAccessor#readAliasFrom(java.lang.Object)
 		 */
-		public Object readAliasFrom(Bson source) {
+		public Alias readAliasFrom(Bson source) {
 
 			if (source instanceof List) {
-				return null;
+				return Alias.NONE;
 			}
 
 			if (source instanceof Document) {
-				return ((Document) source).get(typeKey);
+				return Alias.ofOptional(Optional.ofNullable(((Document) source).get(typeKey)));
 			} else if (source instanceof DBObject) {
-				return ((DBObject) source).get(typeKey);
+				return Alias.ofOptional(Optional.ofNullable(((DBObject) source).get(typeKey)));
 			}
 
 			throw new IllegalArgumentException("Cannot read alias from " + source.getClass());

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/core/convert/DefaultMongoTypeMapper.java

@@ -18,6 +18,8 @@
 import java.util.Arrays;
 import java.util.Iterator;
 import java.util.Map;
+import java.util.Optional;
+import java.util.function.Supplier;
 
 import org.bson.Document;
 import org.bson.conversions.Bson;
@@ -89,6 +91,15 @@ public void put(MongoPersistentProperty prop, Object value) {
 		}
 	}
 
+	public void computeIfAbsent(MongoPersistentProperty prop, Supplier<Optional<Object>> supplier) {
+
+		if (hasValue(prop)) {
+			return;
+		}
+
+		supplier.get().ifPresent(it -> put(prop, it));
+	}
+
 	/**
 	 * Returns the value the given {@link MongoPersistentProperty} refers to. By default this will be a direct field but
 	 * the method will also transparently resolve nested values the {@link MongoPersistentProperty} might refer to through