DATAMONGO-1271 - Polishing.

Removed non Java 6 language features, reworked and added a few tests.

Original Pull Request: #322

Author: christophstrobl

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

@@ -29,7 +29,6 @@
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
-import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.core.CollectionFactory;
 import org.springframework.core.convert.ConversionException;
 import org.springframework.core.convert.ConversionService;
@@ -56,6 +55,7 @@
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.data.mongodb.core.mapping.event.AfterConvertEvent;
 import org.springframework.data.mongodb.core.mapping.event.AfterLoadEvent;
+import org.springframework.data.mongodb.core.mapping.event.MongoMappingEvent;
 import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.expression.spel.standard.SpelExpressionParser;
@@ -871,7 +871,7 @@ protected DBRef createDBRef(Object target, MongoPersistentProperty property) {
 	@Override
 	public Object getValueInternal(MongoPersistentProperty prop, DBObject dbo, SpELExpressionEvaluator evaluator,
 			ObjectPath path) {
-		return new MongoDbPropertyValueProvider(dbo, evaluator, path, false).getPropertyValue(prop);
+		return new MongoDbPropertyValueProvider(dbo, evaluator, path).getPropertyValue(prop);
 	}
 
 	/**
@@ -1104,7 +1104,6 @@ private class MongoDbPropertyValueProvider implements PropertyValueProvider<Mong
 		private final DBObjectAccessor source;
 		private final SpELExpressionEvaluator evaluator;
 		private final ObjectPath path;
-		private final boolean ignoreLazyDBRefProperties;
 
 		/**
 		 * Creates a new {@link MongoDbPropertyValueProvider} for the given source, {@link SpELExpressionEvaluator} and
@@ -1115,18 +1114,13 @@ private class MongoDbPropertyValueProvider implements PropertyValueProvider<Mong
 		 * @param path can be {@literal null}.
 		 */
 		public MongoDbPropertyValueProvider(DBObject source, SpELExpressionEvaluator evaluator, ObjectPath path) {
-			this(source, evaluator, path, true); // ignoring by default
-		}
 
-		MongoDbPropertyValueProvider(DBObject source, SpELExpressionEvaluator evaluator, ObjectPath path,
-				boolean ignoreLazyDBRefProperties) {
 			Assert.notNull(source);
 			Assert.notNull(evaluator);
 
 			this.source = new DBObjectAccessor(source);
 			this.evaluator = evaluator;
 			this.path = path;
-			this.ignoreLazyDBRefProperties = ignoreLazyDBRefProperties;
 		}
 
 		/* 
@@ -1141,12 +1135,6 @@ public <T> T getPropertyValue(MongoPersistentProperty property) {
 			if (value == null) {
 				return null;
 			}
-			if (this.ignoreLazyDBRefProperties && property.isDbReference() && property.getDBRef().lazy()) { // lazy DBRef,
-																																																			// BasicDBList are
-																																																			// resolved later
-																																																			// by default
-				return null;
-			}
 
 			return readValue(value, property.getTypeInformation(), path);
 		}
@@ -1208,24 +1196,47 @@ private <T> T readValue(Object value, TypeInformation<?> type, ObjectPath path)
 
 	@SuppressWarnings("unchecked")
 	private <T> T potentiallyReadOrResolveDbRef(DBRef dbref, TypeInformation<?> type, ObjectPath path, Class<?> rawType) {
+
 		if (rawType.equals(DBRef.class)) {
 			return (T) dbref;
 		}
+
 		Object object = dbref == null ? null : path.getPathItem(dbref.getId(), dbref.getCollectionName());
 		return (T) (object != null ? object : readAndConvertDBRef(dbref, type, path, rawType));
 	}
 
-	private <T> T readAndConvertDBRef(DBRef dbref, TypeInformation<?> type, ObjectPath path, Class<?> rawType) {
-		DBObject readRef = readRef(dbref);
+	@SuppressWarnings("unchecked")
+	private <T> T readAndConvertDBRef(DBRef dbref, TypeInformation<?> type, ObjectPath path, final Class<?> rawType) {
+
+		final DBObject readRef = readRef(dbref);
 		final String collectionName = dbref.getCollectionName();
-		if (canPublishEvent())
-			((ApplicationEventPublisher) this.applicationContext)
-					.publishEvent(new AfterLoadEvent<T>(readRef, (Class<T>) rawType, collectionName));
-		T t = (T) read(type, readRef, path);
-		if (canPublishEvent())
-			((ApplicationEventPublisher) this.applicationContext)
-					.publishEvent(new AfterConvertEvent<T>(readRef, t, collectionName));
-		return t;
+
+		maybeEmitEvent(new MappingEventSupplier<T>() {
+
+			@Override
+			public MongoMappingEvent<T> get() {
+				return (MongoMappingEvent<T>) new AfterLoadEvent<T>(readRef, (Class<T>) rawType, collectionName);
+			}
+		});
+
+		final T target = (T) read(type, readRef, path);
+
+		maybeEmitEvent(new MappingEventSupplier<T>() {
+
+			@Override
+			public MongoMappingEvent<T> get() {
+				return (MongoMappingEvent<T>) new AfterConvertEvent<T>(readRef, target, collectionName);
+			}
+		});
+
+		return target;
+	}
+
+	private <T> void maybeEmitEvent(MappingEventSupplier<T> event) {
+
+		if (canPublishEvent()) {
+			this.applicationContext.publishEvent(event.get());
+		}
 	}
 
 	private boolean canPublishEvent() {
@@ -1252,4 +1263,14 @@ DBObject readRef(DBRef ref) {
 	static class NestedDocument {
 
 	}
+
+	/**
+	 * @author Christoph Strobl
+	 * @param <T>
+	 * @since 1.10
+	 */
+	private static interface MappingEventSupplier<T> {
+		MongoMappingEvent<T> get();
+	}
+
 }