DATAMONGO-1849 - Polishing.

Fix generics usage in MappingMongoJsonSchemaCreator. Make fields final. Rename MappingMongoConverter.computeWriteTarget to getWriteTarget and expose it publicly for reuse in custom DefaultTypeMapper setups without the need to subclass MappingMongoConverter.

Remove Nullability functionality for required fields as nullability indicators should originate from PersistentProperty and PreferredConstructor. Update documentation.

Related ticket: DATACMNS-1513
Original pull request: #733.

Author: mp911de

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

@@ -21,12 +21,11 @@
 import java.util.EnumSet;
 import java.util.List;
 
-import org.springframework.data.mapping.PersistentEntity;
 import org.springframework.data.mapping.PersistentProperty;
-import org.springframework.data.mapping.SimplePropertyHandler;
 import org.springframework.data.mapping.context.MappingContext;
 import org.springframework.data.mongodb.core.convert.MongoConverter;
 import org.springframework.data.mongodb.core.mapping.Field;
+import org.springframework.data.mongodb.core.mapping.MongoPersistentEntity;
 import org.springframework.data.mongodb.core.mapping.MongoPersistentProperty;
 import org.springframework.data.mongodb.core.schema.IdentifiableJsonSchemaProperty.ObjectJsonSchemaProperty;
 import org.springframework.data.mongodb.core.schema.JsonSchemaObject;
@@ -35,7 +34,6 @@
 import org.springframework.data.mongodb.core.schema.MongoJsonSchema;
 import org.springframework.data.mongodb.core.schema.MongoJsonSchema.MongoJsonSchemaBuilder;
 import org.springframework.data.mongodb.core.schema.TypedJsonSchemaObject;
-import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
 import org.springframework.util.ClassUtils;
 import org.springframework.util.CollectionUtils;
@@ -45,26 +43,28 @@
  * {@link MongoJsonSchemaCreator} implementation using both {@link MongoConverter} and {@link MappingContext} to obtain
  * domain type meta information which considers {@link org.springframework.data.mongodb.core.mapping.Field field names}
  * and {@link org.springframework.data.mongodb.core.convert.MongoCustomConversions custom conversions}.
- * 
+ *
  * @author Christoph Strobl
+ * @author Mark Paluch
  * @since 2.2
  */
 class MappingMongoJsonSchemaCreator implements MongoJsonSchemaCreator {
 
-	private MongoConverter converter;
-	private MappingContext mappingContext;
+	private final MongoConverter converter;
+	private final MappingContext<MongoPersistentEntity<?>, MongoPersistentProperty> mappingContext;
 
 	/**
 	 * Create a new instance of {@link MappingMongoJsonSchemaCreator}.
 	 *
 	 * @param converter must not be {@literal null}.
 	 */
+	@SuppressWarnings("unchecked")
 	MappingMongoJsonSchemaCreator(MongoConverter converter) {
 
 		Assert.notNull(converter, "Converter must not be null!");
 		this.converter = converter;
-		this.mappingContext = converter.getMappingContext();
-
+		this.mappingContext = (MappingContext<MongoPersistentEntity<?>, MongoPersistentProperty>) converter
+				.getMappingContext();
 	}
 
 	/*
@@ -74,7 +74,7 @@ class MappingMongoJsonSchemaCreator implements MongoJsonSchemaCreator {
 	@Override
 	public MongoJsonSchema createSchemaFor(Class<?> type) {
 
-		PersistentEntity<?, ?> entity = mappingContext.getPersistentEntity(type);
+		MongoPersistentEntity<?> entity = mappingContext.getRequiredPersistentEntity(type);
 		MongoJsonSchemaBuilder schemaBuilder = MongoJsonSchema.builder();
 
 		List<JsonSchemaProperty> schemaProperties = computePropertiesForEntity(Collections.emptyList(), entity);
@@ -84,35 +84,33 @@ public MongoJsonSchema createSchemaFor(Class<?> type) {
 
 	}
 
-	private List<JsonSchemaProperty> computePropertiesForEntity(List<PersistentProperty> path,
-			PersistentEntity<?, ?> entity) {
+	private List<JsonSchemaProperty> computePropertiesForEntity(List<MongoPersistentProperty> path,
+			MongoPersistentEntity<?> entity) {
 
 		List<JsonSchemaProperty> schemaProperties = new ArrayList<>();
-		entity.doWithProperties((SimplePropertyHandler) nested -> {
 
-			ArrayList<PersistentProperty> currentPath = new ArrayList<>(path);
+		for (MongoPersistentProperty nested : entity) {
+
+			List<MongoPersistentProperty> currentPath = new ArrayList<>(path);
 
 			if (path.contains(nested)) { // cycle guard
 				schemaProperties.add(createSchemaProperty(computePropertyFieldName(CollectionUtils.lastElement(currentPath)),
 						Object.class, false));
-				return;
+				break;
 			}
 
 			currentPath.add(nested);
-			JsonSchemaProperty jsonSchemaProperty = computeSchemaForProperty(currentPath, entity);
-			if (jsonSchemaProperty != null) {
-				schemaProperties.add(jsonSchemaProperty);
-			}
-		});
+			schemaProperties.add(computeSchemaForProperty(currentPath));
+		}
 
 		return schemaProperties;
 	}
 
-	private JsonSchemaProperty computeSchemaForProperty(List<PersistentProperty> path, PersistentEntity<?, ?> parent) {
+	private JsonSchemaProperty computeSchemaForProperty(List<MongoPersistentProperty> path) {
 
-		PersistentProperty property = CollectionUtils.lastElement(path);
+		MongoPersistentProperty property = CollectionUtils.lastElement(path);
 
-		boolean required = isRequiredProperty(parent, property);
+		boolean required = isRequiredProperty(property);
 		Class<?> rawTargetType = computeTargetType(property); // target type before conversion
 		Class<?> targetType = converter.getTypeMapper().getWriteTargetTypeFor(rawTargetType); // conversion target type
 
@@ -133,12 +131,12 @@ private JsonSchemaProperty computeSchemaForProperty(List<PersistentProperty> pat
 		return createSchemaProperty(fieldName, targetType, required);
 	}
 
-	private JsonSchemaProperty createObjectSchemaPropertyForEntity(List<PersistentProperty> path,
-			PersistentProperty property, boolean required) {
+	private JsonSchemaProperty createObjectSchemaPropertyForEntity(List<MongoPersistentProperty> path,
+			MongoPersistentProperty property, boolean required) {
 
 		ObjectJsonSchemaProperty target = JsonSchemaProperty.object(property.getName());
 		List<JsonSchemaProperty> nestedProperties = computePropertiesForEntity(path,
-				mappingContext.getPersistentEntity(property));
+				mappingContext.getRequiredPersistentEntity(property));
 
 		return createPotentiallyRequiredSchemaProperty(
 				target.properties(nestedProperties.toArray(new JsonSchemaProperty[0])), required);
@@ -147,6 +145,7 @@ private JsonSchemaProperty createObjectSchemaPropertyForEntity(List<PersistentPr
 	private JsonSchemaProperty createEnumSchemaProperty(String fieldName, Class<?> targetType, boolean required) {
 
 		List<Object> possibleValues = new ArrayList<>();
+
 		for (Object enumValue : EnumSet.allOf((Class) targetType)) {
 			possibleValues.add(converter.convertToMongoType(enumValue));
 		}
@@ -178,10 +177,8 @@ private String computePropertyFieldName(PersistentProperty property) {
 				: property.getName();
 	}
 
-	private boolean isRequiredProperty(PersistentEntity<?, ?> parent, PersistentProperty property) {
-
-		return (parent.isConstructorArgument(property) && !property.isAnnotationPresent(Nullable.class))
-				|| property.getType().isPrimitive();
+	private boolean isRequiredProperty(PersistentProperty property) {
+		return property.getType().isPrimitive();
 	}
 
 	private Class<?> computeTargetType(PersistentProperty<?> property) {
@@ -196,7 +193,7 @@ private Class<?> computeTargetType(PersistentProperty<?> property) {
 		}
 
 		if (mongoProperty.hasExplicitWriteTarget()) {
-			return mongoProperty.findAnnotation(Field.class).targetType().getJavaClass();
+			return mongoProperty.getRequiredAnnotation(Field.class).targetType().getJavaClass();
 		}
 
 		return mongoProperty.getFieldType() != mongoProperty.getActualType() ? Object.class : mongoProperty.getFieldType();

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

@@ -23,29 +23,30 @@
  * {@link MongoJsonSchemaCreator} extracts the {@link MongoJsonSchema} for a given {@link Class} by applying the
  * following mapping rules.
  * <p>
- * <strong>Required Properties</strong><br />
- * - All Constructor arguments annotated with {@link org.springframework.lang.Nullable}. <br />
- * - Properties of primitive type. <br />
- * </p>
- * <p>
- * <strong>Ignored Properties</strong><br />
- * - All properties annotated with {@link org.springframework.data.annotation.Transient}. <br />
- * </p>
- * <p>
- * <strong>Property Type Mapping</strong><br />
- * - {@link java.lang.Object} -> {@code type : 'object'} <br />
- * - {@link java.util.Arrays} -> {@code type : 'array'} <br />
- * - {@link java.util.Collection} -> {@code type : 'array'} <br />
- * - {@link java.util.Map} -> {@code type : 'object'} <br />
- * - {@link java.lang.Enum} -> {@code type : 'string', enum : [the enum values]} <br />
- * - Simple Types -> {@code type : 'the corresponding bson type' } <br />
- * - Domain Types -> {@code type : 'object', properties : &#123;the types properties&#125; } <br />
+ * <strong>Required Properties</strong>
+ * <ul>
+ * <li>Properties of primitive type</li>
+ * </ul>
+ * <strong>Ignored Properties</strong>
+ * <ul>
+ * <li>All properties annotated with {@link org.springframework.data.annotation.Transient}</li>
+ * </ul>
+ * <strong>Property Type Mapping</strong>
+ * <ul>
+ * <li>{@link java.lang.Object} -> {@code type : 'object'}</li>
+ * <li>{@link java.util.Arrays} -> {@code type : 'array'}</li>
+ * <li>{@link java.util.Collection} -> {@code type : 'array'}</li>
+ * <li>{@link java.util.Map} -> {@code type : 'object'}</li>
+ * <li>{@link java.lang.Enum} -> {@code type : 'string', enum : [the enum values]}</li>
+ * <li>Simple Types -> {@code type : 'the corresponding bson type' }</li>
+ * <li>Domain Types -> {@code type : 'object', properties : &#123;the types properties&#125; }</li>
+ * </ul>
  * <br />
  * {@link org.springframework.data.annotation.Id _id} properties using types that can be converted into
  * {@link org.bson.types.ObjectId} like {@link String} will be mapped to {@code type : 'object'} unless there is more
  * specific information available via the {@link org.springframework.data.mongodb.core.mapping.MongoId} annotation.
  * </p>
- * 
+ *
  * @author Christoph Strobl
  * @since 2.2
  */
@@ -66,7 +67,7 @@ public interface MongoJsonSchemaCreator {
 	 * @param mongoConverter must not be {@literal null}.
 	 * @return new instance of {@link MongoJsonSchemaCreator}.
 	 */
-	static MongoJsonSchemaCreator jsonSchemaCreator(MongoConverter mongoConverter) {
+	static MongoJsonSchemaCreator create(MongoConverter mongoConverter) {
 
 		Assert.notNull(mongoConverter, "MongoConverter must not be null!");
 		return new MappingMongoJsonSchemaCreator(mongoConverter);

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

@@ -15,14 +15,16 @@
  */
 package org.springframework.data.mongodb.core.convert;
 
-import java.util.Arrays;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 import java.util.Set;
-import java.util.function.Function;
+import java.util.function.UnaryOperator;
 
 import org.bson.Document;
 import org.bson.conversions.Bson;
+
+import org.springframework.data.convert.CustomConversions;
 import org.springframework.data.convert.DefaultTypeMapper;
 import org.springframework.data.convert.SimpleTypeInformationMapper;
 import org.springframework.data.convert.TypeAliasAccessor;
@@ -59,29 +61,58 @@ public class DefaultMongoTypeMapper extends DefaultTypeMapper<Bson> implements M
 
 	private final TypeAliasAccessor<Bson> accessor;
 	private final @Nullable String typeKey;
-	private Function<Class<?>, Class<?>> writeTarget = it -> it;
+	private UnaryOperator<Class<?>> writeTarget = UnaryOperator.identity();
 
+	/**
+	 * Create a new {@link MongoTypeMapper} with fully-qualified type hints using {@code _class}.
+	 */
 	public DefaultMongoTypeMapper() {
 		this(DEFAULT_TYPE_KEY);
 	}
 
+	/**
+	 * Create a new {@link MongoTypeMapper} with fully-qualified type hints using {@code typeKey}.
+	 *
+	 * @param typeKey name of the field to read and write type hints. Can be {@literal null} to disable type hints.
+	 */
 	public DefaultMongoTypeMapper(@Nullable String typeKey) {
-		this(typeKey, Arrays.asList(new SimpleTypeInformationMapper()));
+		this(typeKey, Collections.singletonList(new SimpleTypeInformationMapper()));
 	}
 
+	/**
+	 * Create a new {@link MongoTypeMapper} with fully-qualified type hints using {@code typeKey}.
+	 *
+	 * @param typeKey name of the field to read and write type hints. Can be {@literal null} to disable type hints.
+	 * @param mappingContext the mapping context.
+	 */
 	public DefaultMongoTypeMapper(@Nullable String typeKey,
 			MappingContext<? extends PersistentEntity<?, ?>, ?> mappingContext) {
 		this(typeKey, new DocumentTypeAliasAccessor(typeKey), mappingContext,
-				Arrays.asList(new SimpleTypeInformationMapper()));
+				Collections.singletonList(new SimpleTypeInformationMapper()));
 	}
 
+	/**
+	 * Create a new {@link MongoTypeMapper} with fully-qualified type hints using {@code typeKey}. Uses
+	 * {@link UnaryOperator} to apply {@link CustomConversions}.
+	 *
+	 * @param typeKey name of the field to read and write type hints. Can be {@literal null} to disable type hints.
+	 * @param mappingContext the mapping context to look up types using type hints.
+	 * @see MappingMongoConverter#getWriteTarget(Class)
+	 */
 	public DefaultMongoTypeMapper(@Nullable String typeKey,
-			MappingContext<? extends PersistentEntity<?, ?>, ?> mappingContext, Function<Class<?>, Class<?>> writeTarget) {
+			MappingContext<? extends PersistentEntity<?, ?>, ?> mappingContext, UnaryOperator<Class<?>> writeTarget) {
 		this(typeKey, new DocumentTypeAliasAccessor(typeKey), mappingContext,
-				Arrays.asList(new SimpleTypeInformationMapper()));
+				Collections.singletonList(new SimpleTypeInformationMapper()));
 		this.writeTarget = writeTarget;
 	}
 
+	/**
+	 * Create a new {@link MongoTypeMapper} with fully-qualified type hints using {@code typeKey}. Uses
+	 * {@link TypeInformationMapper} to map type hints.
+	 *
+	 * @param typeKey name of the field to read and write type hints. Can be {@literal null} to disable type hints.
+	 * @param mappers
+	 */
 	public DefaultMongoTypeMapper(@Nullable String typeKey, List<? extends TypeInformationMapper> mappers) {
 		this(typeKey, new DocumentTypeAliasAccessor(typeKey), null, mappers);
 	}

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

@@ -34,6 +34,7 @@
 import org.bson.types.ObjectId;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
+
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
@@ -122,7 +123,7 @@ public MappingMongoConverter(DbRefResolver dbRefResolver,
 		this.dbRefResolver = dbRefResolver;
 		this.mappingContext = mappingContext;
 		this.typeMapper = new DefaultMongoTypeMapper(DefaultMongoTypeMapper.DEFAULT_TYPE_KEY, mappingContext,
-				this::computeWriteTarget);
+				this::getWriteTarget);
 		this.idMapper = new QueryMapper(this);
 
 		this.spELContext = new SpELContext(DocumentPropertyAccessor.INSTANCE);
@@ -672,7 +673,7 @@ protected List<Object> createCollection(Collection<?> collection, MongoPersisten
 		if (!property.isDbReference()) {
 
 			if (property.hasExplicitWriteTarget()) {
-				return writeCollectionInternal(collection, new HijackedTypeInformation<>(property), new ArrayList<>());
+				return writeCollectionInternal(collection, new TypeInformationWrapper<>(property), new ArrayList<>());
 			}
 			return writeCollectionInternal(collection, property.getTypeInformation(), new BasicDBList());
 		}
@@ -1608,6 +1609,7 @@ private boolean canPublishEvent() {
 	 * @param ref
 	 * @return
 	 */
+	@Nullable
 	Document readRef(DBRef ref) {
 		return dbRefResolver.fetch(ref);
 	}
@@ -1630,7 +1632,7 @@ List<Document> bulkReadRefs(List<DBRef> references) {
 	 * @return
 	 * @since 2.2
 	 */
-	protected Class<?> computeWriteTarget(Class<?> source) {
+	public Class<?> getWriteTarget(Class<?> source) {
 		return conversions.getCustomWriteTarget(source).orElse(source);
 	}
 
@@ -1702,12 +1704,12 @@ public <T> T getParameterValue(Parameter<T, MongoPersistentProperty> parameter)
 		}
 	}
 
-	private static class HijackedTypeInformation<S> implements TypeInformation<S> {
+	private static class TypeInformationWrapper<S> implements TypeInformation<S> {
 
 		private MongoPersistentProperty persistentProperty;
 		private TypeInformation<?> delegate;
 
-		public HijackedTypeInformation(MongoPersistentProperty property) {
+		public TypeInformationWrapper(MongoPersistentProperty property) {
 
 			this.persistentProperty = property;
 			this.delegate = property.getTypeInformation();

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

@@ -31,8 +31,9 @@
  * <p/>
  * Bson types are identified by a {@code byte} {@link #getBsonType() value}. This enumeration typically returns the
  * according bson type value except for {@link #IMPLICIT} which is a marker to derive the field type from a property.
- * 
+ *
  * @author Mark Paluch
+ * @author Christoph Strobl
  * @since 2.2
  * @see org.bson.BsonType
  */
@@ -67,7 +68,7 @@ public enum FieldType {
 
 	/**
 	 * Returns the BSON type identifier. Can be {@code -1} if {@link FieldType} maps to a synthetic Bson type.
-	 * 
+	 *
 	 * @return the BSON type identifier. Can be {@code -1} if {@link FieldType} maps to a synthetic Bson type.
 	 */
 	public int getBsonType() {
@@ -76,7 +77,7 @@ public int getBsonType() {
 
 	/**
 	 * Returns the Java class used to represent the type.
-	 * 
+	 *
 	 * @return the Java class used to represent the type.
 	 */
 	public Class<?> getJavaClass() {