DATAMONGO-607 - Introduced FieldNamingStrategy SPI interface.

MongoMappingContext can now get a FieldNamingStrategy configured to allow the customization of field names used to persist property values to in case *no manual mapping is defined* (e.g. through @Field). The default strategy will simply use the property name as it did before.

We now also expose a abbreviate-field-names attribute on the <mongo:mapping-context /> XML namespace element to transparently register a CamelCaseAbbreviatingFieldNamingStrategy which abbreviates the property's name to the first letters of its camel-case structure. A property fooBar would then be persisted to a field named fb. If you're not using the XML namespace simply configure the strategy on your MongoMappingContext instance.

To avoid field name mapping ambiguities being introduced through a custom FieldNamingStrategy (imagine the camel-case strategy just mentioned and two properties lastname and level which would both map to l) the PersistentEntity implementation verifies the mapping metadata and throws an exception in case an ambiguity is found.

spring-data-mongodb/src/main/java/org/springframework/data/mongodb/config/MappingMongoConverterParser.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 the original author or authors.
+ * Copyright 2011-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -54,6 +54,7 @@ import org.springframework.data.mapping.context.MappingContextIsNewStrategyFacto
 import org.springframework.data.mongodb.core.convert.CustomConversions;
 import org.springframework.data.mongodb.core.convert.MappingMongoConverter;
 import org.springframework.data.mongodb.core.index.MongoPersistentEntityIndexCreator;
+import org.springframework.data.mongodb.core.mapping.CamelCaseAbbreviatingFieldNamingStrategy;
 import org.springframework.data.mongodb.core.mapping.Document;
 import org.springframework.data.mongodb.core.mapping.MongoMappingContext;
 import org.springframework.data.mongodb.core.mapping.event.ValidatingMongoEventListener;
@@ -200,6 +201,12 @@ public class MappingMongoConverterParser implements BeanDefinitionParser {
 			mappingContextBuilder.addPropertyValue("simpleTypeHolder", simpleTypesDefinition);
 		}
 
+		String abbreviateFieldNames = element.getAttribute("abbreviate-field-names");
+		if ("true".equals(abbreviateFieldNames)) {
+			mappingContextBuilder.addPropertyValue("fieldNamingStrategy", new RootBeanDefinition(
+					CamelCaseAbbreviatingFieldNamingStrategy.class));
+		}
+
 		ctxRef = converterId + "." + MAPPING_CONTEXT;
 
 		parserContext.registerBeanComponent(componentDefinitionBuilder.getComponent(mappingContextBuilder, ctxRef));

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 the original author or authors.
+ * Copyright 2011-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -16,13 +16,19 @@
 package org.springframework.data.mongodb.core.mapping;
 
 import java.util.Comparator;
+import java.util.HashMap;
+import java.util.Map;
 
 import org.springframework.beans.BeansException;
 import org.springframework.context.ApplicationContext;
 import org.springframework.context.ApplicationContextAware;
 import org.springframework.context.expression.BeanFactoryAccessor;
 import org.springframework.context.expression.BeanFactoryResolver;
+import org.springframework.data.mapping.Association;
+import org.springframework.data.mapping.AssociationHandler;
+import org.springframework.data.mapping.PropertyHandler;
 import org.springframework.data.mapping.model.BasicPersistentEntity;
+import org.springframework.data.mapping.model.MappingException;
 import org.springframework.data.mongodb.MongoCollectionUtils;
 import org.springframework.data.util.TypeInformation;
 import org.springframework.expression.Expression;
@@ -41,6 +47,7 @@ import org.springframework.util.StringUtils;
 public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, MongoPersistentProperty> implements
 		MongoPersistentEntity<T>, ApplicationContextAware {
 
+	private static final String AMBIGUOUS_FIELD_MAPPING = "Ambiguous field mapping detected! Both %s and %s map to the same field name %s! Disambiguate using @Field annotation!";
 	private final String collection;
 	private final SpelExpressionParser parser;
 	private final StandardEvaluationContext context;
@@ -89,6 +96,19 @@ public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, Mong
 		return expression.getValue(context, String.class);
 	}
 
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mapping.model.BasicPersistentEntity#verify()
+	 */
+	@Override
+	public void verify() {
+
+		AssertFieldNameUniquenessHandler handler = new AssertFieldNameUniquenessHandler();
+
+		doWithProperties(handler);
+		doWithAssociations(handler);
+	}
+
 	/**
 	 * {@link Comparator} implementation inspecting the {@link MongoPersistentProperty}'s order.
 	 * 
@@ -115,4 +135,37 @@ public class BasicMongoPersistentEntity<T> extends BasicPersistentEntity<T, Mong
 			return o1.getFieldOrder() - o2.getFieldOrder();
 		}
 	}
+
+	/**
+	 * Handler to collect {@link MongoPersistentProperty} instances and check that each of them is mapped to a distinct
+	 * field name.
+	 * 
+	 * @author Oliver Gierke
+	 */
+	private static class AssertFieldNameUniquenessHandler implements PropertyHandler<MongoPersistentProperty>,
+			AssociationHandler<MongoPersistentProperty> {
+
+		private final Map<String, MongoPersistentProperty> properties = new HashMap<String, MongoPersistentProperty>();
+
+		public void doWithPersistentProperty(MongoPersistentProperty persistentProperty) {
+			assertUniqueness(persistentProperty);
+		}
+
+		public void doWithAssociation(Association<MongoPersistentProperty> association) {
+			assertUniqueness(association.getInverse());
+		}
+
+		private void assertUniqueness(MongoPersistentProperty property) {
+
+			String fieldName = property.getFieldName();
+			MongoPersistentProperty existingProperty = properties.get(fieldName);
+
+			if (existingProperty != null) {
+				throw new MappingException(String.format(AMBIGUOUS_FIELD_MAPPING, property.toString(),
+						existingProperty.toString(), fieldName));
+			}
+
+			properties.put(fieldName, property);
+		}
+	}
 }

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 the original author or authors.
+ * Copyright 2011-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -26,6 +26,7 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.data.mapping.Association;
 import org.springframework.data.mapping.model.AnnotationBasedPersistentProperty;
+import org.springframework.data.mapping.model.MappingException;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.util.ReflectionUtils;
 import org.springframework.util.StringUtils;
@@ -60,6 +61,8 @@ public class BasicMongoPersistentProperty extends AnnotationBasedPersistentPrope
 		CAUSE_FIELD = ReflectionUtils.findField(Throwable.class, "cause");
 	}
 
+	private final FieldNamingStrategy fieldNamingStrategy;
+
 	/**
 	 * Creates a new {@link BasicMongoPersistentProperty}.
 	 * 
@@ -67,10 +70,14 @@ public class BasicMongoPersistentProperty extends AnnotationBasedPersistentPrope
 	 * @param propertyDescriptor
 	 * @param owner
 	 * @param simpleTypeHolder
+	 * @param fieldNamingStrategy
 	 */
 	public BasicMongoPersistentProperty(Field field, PropertyDescriptor propertyDescriptor,
-			MongoPersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder) {
+			MongoPersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder, FieldNamingStrategy fieldNamingStrategy) {
+
 		super(field, propertyDescriptor, owner, simpleTypeHolder);
+		this.fieldNamingStrategy = fieldNamingStrategy == null ? PropertyNameFieldNamingStrategy.INSTANCE
+				: fieldNamingStrategy;
 
 		if (isIdProperty() && getFieldName() != ID_FIELD_NAME) {
 			LOG.warn("Customizing field name for id property not allowed! Custom name will not be considered!");
@@ -113,9 +120,20 @@ public class BasicMongoPersistentProperty extends AnnotationBasedPersistentPrope
 			return ID_FIELD_NAME;
 		}
 
-		org.springframework.data.mongodb.core.mapping.Field annotation = getField().getAnnotation(
+		org.springframework.data.mongodb.core.mapping.Field annotation = findAnnotation(org.springframework.data.mongodb.core.mapping.Field.class);
-				org.springframework.data.mongodb.core.mapping.Field.class);
+
-		return annotation != null && StringUtils.hasText(annotation.value()) ? annotation.value() : field.getName();
+		if (annotation != null && StringUtils.hasText(annotation.value())) {
+			return annotation.value();
+		}
+
+		String fieldName = fieldNamingStrategy.getFieldName(this);
+
+		if (!StringUtils.hasText(fieldName)) {
+			throw new MappingException(String.format("Invalid (null or empty) field name returned for property %s by %s!",
+					this, fieldNamingStrategy.getClass()));
+		}
+
+		return fieldName;
 	}
 
 	/*

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 the original author or authors.
+ * Copyright 2011-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -38,10 +38,11 @@ public class CachingMongoPersistentProperty extends BasicMongoPersistentProperty
 	 * @param propertyDescriptor
 	 * @param owner
 	 * @param simpleTypeHolder
+	 * @param fieldNamingStrategy
 	 */
 	public CachingMongoPersistentProperty(Field field, PropertyDescriptor propertyDescriptor,
-			MongoPersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder) {
+			MongoPersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder, FieldNamingStrategy fieldNamingStrategy) {
-		super(field, propertyDescriptor, owner, simpleTypeHolder);
+		super(field, propertyDescriptor, owner, simpleTypeHolder, fieldNamingStrategy);
 	}
 
 	/*

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

@@ -0,0 +1,46 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.mapping;
+
+import java.util.Locale;
+
+/**
+ * {@link FieldNamingStrategy} that abbreviates field names by using the very first letter of the camel case parts of
+ * the {@link MongoPersistentProperty}'s name.
+ * 
+ * @since 1.3
+ * @author Oliver Gierke
+ */
+public class CamelCaseAbbreviatingFieldNamingStrategy implements FieldNamingStrategy {
+
+	private static final String CAMEL_CASE_PATTERN = "(?<!(^|[A-Z]))(?=[A-Z])|(?<!^)(?=[A-Z][a-z])";
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.mapping.FieldNamingStrategy#getFieldName(org.springframework.data.mongodb.core.mapping.MongoPersistentProperty)
+	 */
+	public String getFieldName(MongoPersistentProperty property) {
+
+		String[] parts = property.getName().split(CAMEL_CASE_PATTERN);
+		StringBuilder builder = new StringBuilder();
+
+		for (String part : parts) {
+			builder.append(part.substring(0, 1).toLowerCase(Locale.US));
+		}
+
+		return builder.toString();
+	}
+}

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.mapping;
+
+/**
+ * SPI interface to determine how to name document fields in cases the field name is not manually defined.
+ * 
+ * @see Field
+ * @see PropertyNameFieldNamingStrategy
+ * @see CamelCaseAbbreviatingFieldNamingStrategy
+ * @since 1.3
+ * @author Oliver Gierke
+ */
+public interface FieldNamingStrategy {
+
+	/**
+	 * Returns the field name to be used for the given {@link MongoPersistentProperty}.
+	 * 
+	 * @param property must not be {@literal null} or empty;
+	 * @return
+	 */
+	String getFieldName(MongoPersistentProperty property);
+}

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 the original author or authors.
+ * Copyright 2011-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -37,6 +37,9 @@ import org.springframework.data.util.TypeInformation;
 public class MongoMappingContext extends AbstractMappingContext<BasicMongoPersistentEntity<?>, MongoPersistentProperty>
 		implements ApplicationContextAware {
 
+	private static final FieldNamingStrategy DEFAULT_NAMING_STRATEGY = PropertyNameFieldNamingStrategy.INSTANCE;
+
+	private FieldNamingStrategy fieldNamingStrategy = DEFAULT_NAMING_STRATEGY;
 	private ApplicationContext context;
 
 	/**
@@ -46,6 +49,17 @@ public class MongoMappingContext extends AbstractMappingContext<BasicMongoPersis
 		setSimpleTypeHolder(MongoSimpleTypes.HOLDER);
 	}
 
+	/**
+	 * Configures the {@link FieldNamingStrategy} to be used to determine the field name if no manual mapping is applied.
+	 * Defaults to a strategy using the plain property name.
+	 * 
+	 * @param fieldNamingStrategy the {@link FieldNamingStrategy} to be used to determine the field name if no manual
+	 *          mapping is applied.
+	 */
+	public void setFieldNamingStrategy(FieldNamingStrategy fieldNamingStrategy) {
+		this.fieldNamingStrategy = fieldNamingStrategy == null ? DEFAULT_NAMING_STRATEGY : fieldNamingStrategy;
+	}
+
 	/*
 	 * (non-Javadoc)
 	 * @see org.springframework.data.mapping.context.AbstractMappingContext#shouldCreatePersistentEntityFor(org.springframework.data.util.TypeInformation)
@@ -62,7 +76,7 @@ public class MongoMappingContext extends AbstractMappingContext<BasicMongoPersis
 	@Override
 	public MongoPersistentProperty createPersistentProperty(Field field, PropertyDescriptor descriptor,
 			BasicMongoPersistentEntity<?> owner, SimpleTypeHolder simpleTypeHolder) {
-		return new CachingMongoPersistentProperty(field, descriptor, owner, simpleTypeHolder);
+		return new CachingMongoPersistentProperty(field, descriptor, owner, simpleTypeHolder, fieldNamingStrategy);
 	}
 
 	/*

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

@@ -0,0 +1,35 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.mapping;
+
+/**
+ * {@link FieldNamingStrategy} simply using the {@link MongoPersistentProperty}'s name.
+ * 
+ * @since 1.3
+ * @author Oliver Gierke
+ */
+public enum PropertyNameFieldNamingStrategy implements FieldNamingStrategy {
+
+	INSTANCE;
+
+	/* 
+	 * (non-Javadoc)
+	 * @see org.springframework.data.mongodb.core.mapping.FieldNamingStrategy#getFieldName(org.springframework.data.mongodb.core.mapping.MongoPersistentProperty)
+	 */
+	public String getFieldName(MongoPersistentProperty property) {
+		return property.getName();
+	}
+}

spring-data-mongodb/src/main/resources/META-INF/spring.schemas

@@ -1,4 +1,5 @@
 http\://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd=org/springframework/data/mongodb/config/spring-mongo-1.0.xsd
 http\://www.springframework.org/schema/data/mongo/spring-mongo-1.1.xsd=org/springframework/data/mongodb/config/spring-mongo-1.1.xsd
 http\://www.springframework.org/schema/data/mongo/spring-mongo-1.2.xsd=org/springframework/data/mongodb/config/spring-mongo-1.2.xsd
-http\://www.springframework.org/schema/data/mongo/spring-mongo.xsd=org/springframework/data/mongodb/config/spring-mongo-1.2.xsd
+http\://www.springframework.org/schema/data/mongo/spring-mongo-1.3.xsd=org/springframework/data/mongodb/config/spring-mongo-1.3.xsd
+http\://www.springframework.org/schema/data/mongo/spring-mongo.xsd=org/springframework/data/mongodb/config/spring-mongo-1.3.xsd

spring-data-mongodb/src/main/resources/org/springframework/data/mongodb/config/spring-mongo-1.3.xsd

@@ -0,0 +1,493 @@
+<?xml version="1.0" encoding="UTF-8" ?>
+<xsd:schema xmlns="http://www.springframework.org/schema/data/mongo"
+						xmlns:xsd="http://www.w3.org/2001/XMLSchema"
+						xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+						xmlns:beans="http://www.springframework.org/schema/beans"
+						xmlns:tool="http://www.springframework.org/schema/tool"
+						xmlns:context="http://www.springframework.org/schema/context"
+						xmlns:repository="http://www.springframework.org/schema/data/repository"
+						targetNamespace="http://www.springframework.org/schema/data/mongo"
+						elementFormDefault="qualified" attributeFormDefault="unqualified">
+
+	<xsd:import namespace="http://www.springframework.org/schema/beans" />
+	<xsd:import namespace="http://www.springframework.org/schema/tool" />
+	<xsd:import namespace="http://www.springframework.org/schema/context" />
+	<xsd:import namespace="http://www.springframework.org/schema/data/repository"
+				schemaLocation="http://www.springframework.org/schema/data/repository/spring-repository.xsd" />
+
+	<xsd:element name="mongo" type="mongoType">
+		<xsd:annotation>
+			<xsd:documentation source="org.springframework.data.mongodb.core.core.MongoFactoryBean"><![CDATA[
+Defines a Mongo instance used for accessing MongoDB'.
+			]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.mongodb.Mongo"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+	</xsd:element>
+
+	<xsd:element name="db-factory">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+Defines a MongoDbFactory for connecting to a specific database
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="id" type="xsd:ID" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The name of the mongo definition (by default "mongoDbFactory").]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="mongo-ref" type="mongoRef" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The reference to a Mongo instance. If not configured a default com.mongodb.Mongo instance will be created.
+					]]>
+					</xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="dbname" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The name of the database to connect to. Default is 'db'.
+							]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="port" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The port to connect to MongoDB server.  Default is 27017
+							]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="host" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The host to connect to a MongoDB server.  Default is localhost
+							]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="username" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The username to use when connecting to a MongoDB server.
+							]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="password" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The password to use when connecting to a MongoDB server.
+							]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="uri" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The Mongo URI string.]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="write-concern">
+				<xsd:annotation>
+					<xsd:documentation>
+					The WriteConcern that will be the default value used when asking the MongoDbFactory for a DB object
+					</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:union memberTypes="writeConcernEnumeration xsd:string"/>
+				</xsd:simpleType>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:attributeGroup name="mongo-repository-attributes">
+		<xsd:attribute name="mongo-template-ref" type="mongoTemplateRef" default="mongoTemplate">
+			<xsd:annotation>
+				<xsd:documentation>
+					The reference to a MongoTemplate. Will default to 'mongoTemplate'.
+				</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="create-query-indexes" type="xsd:boolean" default="false">
+			<xsd:annotation>
+				<xsd:documentation>
+					Enables creation of indexes for queries that get derived from the method name
+					and thus reference domain class properties. Defaults to false.
+				</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:attributeGroup>
+
+	<xsd:element name="repositories">
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="repository:repositories">
+					<xsd:attributeGroup ref="mongo-repository-attributes"/>
+					<xsd:attributeGroup ref="repository:repository-attributes"/>
+				</xsd:extension>
+			</xsd:complexContent>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="mapping-converter">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[Defines a MongoConverter for getting rich mapping functionality.]]></xsd:documentation>
+			<xsd:appinfo>
+				<tool:exports type="org.springframework.data.mongodb.core.convert.MappingMongoConverter" />
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:sequence>
+				<xsd:element name="custom-converters" minOccurs="0">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+        Top-level element that contains one or more custom converters to be used for mapping
+        domain objects to and from Mongo's DBObject]]>
+						</xsd:documentation>
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:sequence>
+							<xsd:element name="converter" type="customConverterType" minOccurs="0" maxOccurs="unbounded"/>
+						</xsd:sequence>
+						<xsd:attribute name="base-package" type="xsd:string" />
+					</xsd:complexType>
+				</xsd:element>
+			</xsd:sequence>
+			<xsd:attribute name="id" type="xsd:ID" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The name of the MappingMongoConverter instance (by default "mappingConverter").]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="base-package" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The base package in which to scan for entities annotated with @Document
+							]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="db-factory-ref" type="xsd:string" use="optional">
+				<xsd:annotation>
+					<xsd:documentation>
+						The reference to a DbFactory.
+					</xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation kind="ref">
+							<tool:assignable-to type="org.springframework.data.mongodb.MongoDbFactory" />
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="mongo-ref" type="mongoRef" use="optional">
+				<xsd:annotation>
+					<xsd:documentation>
+						The reference to a Mongo. Will default to 'mongo'.
+					</xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="mapping-context-ref" type="mappingContextRef" use="optional">
+				<xsd:annotation>
+					<xsd:documentation source="org.springframework.data.mapping.model.MappingContext">
+						The reference to a MappingContext. Will default to 'mappingContext'.
+					</xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="mongo-template-ref" type="mongoTemplateRef" use="optional">
+				<xsd:annotation>
+					<xsd:documentation source="org.springframework.data.mongodb.core.core.MongoTemplate">
+						The reference to a MongoTemplate. Will default to 'mongoTemplate'.
+					</xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="disable-validation" use="optional">
+				<xsd:annotation>
+					<xsd:documentation source="org.springframework.data.mongodb.core.mapping.event.ValidatingMongoEventListener">
+						Disables JSR-303 validation on MongoDB documents before they are saved. By default it is set to false.
+					</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:union memberTypes="xsd:boolean xsd:string"/>
+				</xsd:simpleType>
+			</xsd:attribute>
+			<xsd:attribute name="abbreviate-field-names" use="optional" default="false">
+				<xsd:annotation>
+					<xsd:documentation source="org.springframework.data.mongodb.core.mapping.CamelCaseAbbreviatingFieldNamingStrategy">
+						Enables abbreviating the field names for domain class properties to the
+						first character of their camel case names, e.g. fooBar -> fb.
+					</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:union memberTypes="xsd:boolean xsd:string"/>
+				</xsd:simpleType>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:element name="jmx">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+Defines a JMX Model MBeans for monitoring a MongoDB server'.
+			]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attribute name="mongo-ref" type="mongoRef" use="optional">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The name of the Mongo object that determines what server to monitor. (by default "mongo").]]></xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
+	
+	<xsd:element name="auditing">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="org.springframework.data.mongodb.core.mapping.event.AuditingEventListener" />
+					<tool:exports type="org.springframework.data.auditing.IsNewAwareAuditingHandler" />
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:complexType>
+			<xsd:attributeGroup ref="repository:auditing-attributes" />
+			<xsd:attribute name="mapping-context-ref" type="mappingContextRef" />
+		</xsd:complexType>
+	</xsd:element>
+
+	<xsd:simpleType name="mappingContextRef">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation kind="ref">
+					<tool:assignable-to type="org.springframework.data.mapping.model.MappingContext"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:union memberTypes="xsd:string"/>
+	</xsd:simpleType>
+
+	<xsd:simpleType name="mongoTemplateRef">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation kind="ref">
+					<tool:assignable-to type="org.springframework.data.mongodb.core.core.MongoTemplate"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:union memberTypes="xsd:string"/>
+	</xsd:simpleType>
+
+	<xsd:simpleType name="mongoRef">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation kind="ref">
+					<tool:assignable-to type="org.springframework.data.mongodb.core.core.MongoFactoryBean"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:union memberTypes="xsd:string"/>
+	</xsd:simpleType>
+
+	<xsd:simpleType name="writeConcernEnumeration">
+		<xsd:restriction base="xsd:token">
+			<xsd:enumeration value="NONE" />
+			<xsd:enumeration value="NORMAL" />
+			<xsd:enumeration value="SAFE" />
+			<xsd:enumeration value="FSYNC_SAFE" />
+			<xsd:enumeration value="REPLICAS_SAFE" />
+			<xsd:enumeration value="JOURNAL_SAFE" />
+			<xsd:enumeration value="MAJORITY" />
+		</xsd:restriction>
+	</xsd:simpleType>
+	<!--  MLP
+	<xsd:attributeGroup name="writeConcern">
+		<xsd:attribute name="write-concern">
+			<xsd:simpleType>
+				<xsd:restriction base="xsd:string">
+					<xsd:enumeration value="NONE" />
+					<xsd:enumeration value="NORMAL" />
+					<xsd:enumeration value="SAFE" />
+					<xsd:enumeration value="FSYNC_SAFE" />
+					<xsd:enumeration value="REPLICA_SAFE" />
+					<xsd:enumeration value="JOURNAL_SAFE" />
+					<xsd:enumeration value="MAJORITY" />
+				</xsd:restriction>
+			</xsd:simpleType>
+		</xsd:attribute>
+	</xsd:attributeGroup>
+	-->
+	<xsd:complexType name="mongoType">
+		<xsd:sequence minOccurs="0" maxOccurs="1">
+			<xsd:element name="options" type="optionsType">
+				<xsd:annotation>
+					<xsd:documentation><![CDATA[
+The Mongo driver options
+							]]></xsd:documentation>
+					<xsd:appinfo>
+						<tool:annotation>
+							<tool:exports type="com.mongodb.MongoOptions"/>
+						</tool:annotation>
+					</xsd:appinfo>
+				</xsd:annotation>
+			</xsd:element>
+		</xsd:sequence>
+			<xsd:attribute name="write-concern">
+				<xsd:annotation>
+					<xsd:documentation>
+					The WriteConcern that will be the default value used when asking the MongoDbFactory for a DB object
+					</xsd:documentation>
+				</xsd:annotation>
+				<xsd:simpleType>
+					<xsd:union memberTypes="writeConcernEnumeration xsd:string"/>
+				</xsd:simpleType>
+			</xsd:attribute>		
+		<!-- MLP 
+		<xsd:attributeGroup ref="writeConcern" />
+		-->
+		<xsd:attribute name="id" type="xsd:ID" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The name of the mongo definition (by default "mongo").]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="port" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The port to connect to MongoDB server.  Default is 27017
+							]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="host" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The host to connect to a MongoDB server.  Default is localhost
+							]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="replica-set" type="xsd:string" use="optional">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The comma delimited list of host:port entries to use for replica set/pairs.
+							]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>				
+	</xsd:complexType>
+
+	<xsd:complexType name="optionsType">
+		<xsd:attribute name="connections-per-host" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The number of connections allowed per host.  Will block if run out.	 Default is 10.  System property MONGO.POOLSIZE can override	
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="threads-allowed-to-block-for-connection-multiplier" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The multiplier for connectionsPerHost for # of threads that can block.  Default is 5.
+If connectionsPerHost is 10, and threadsAllowedToBlockForConnectionMultiplier is 5, 
+then 50 threads can block more than that and an exception will be thrown.			
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="max-wait-time" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The max wait time of a blocking thread for a connection. Default is 12000 ms (2 minutes)	
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="connect-timeout" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The connect timeout in milliseconds. 0 is default and infinite.	
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="socket-timeout" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The socket timeout.  0 is default and infinite.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="socket-keep-alive" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The keep alive flag, controls whether or not to have socket keep alive timeout.  Defaults to false.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>		
+		<xsd:attribute name="auto-connect-retry" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+This controls whether or not on a connect, the system retries automatically.  Default is false. 
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="max-auto-connect-retry-time" type="xsd:long">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+The maximum amount of time in millisecons to spend retrying to open connection to the same server. Default is 0, which means to use the default 15s if autoConnectRetry is on. 
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="write-number" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+This specifies the number of servers to wait for on the write operation, and exception raising behavior.  The 'w' option to the getlasterror command.  Defaults to 0.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="write-timeout" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+This controls timeout for write operations in milliseconds.  The 'wtimeout' option to the getlasterror command.  Defaults to 0 (indefinite).  Greater than zero is number of milliseconds to wait.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="write-fsync" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+This controls whether or not to fsync.  The 'fsync' option to the getlasterror command. Defaults to false.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>						
+		<xsd:attribute name="slave-ok" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation><![CDATA[
+This controls if the driver is allowed to read from secondaries or slaves.  Defaults to false.
+				]]></xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>				
+	</xsd:complexType>
+
+	<xsd:group name="beanElementGroup">
+		<xsd:choice>
+			<xsd:element ref="beans:bean"/>
+			<xsd:element ref="beans:ref"/>
+		</xsd:choice>
+	</xsd:group>
+
+	<xsd:complexType name="customConverterType">
+		<xsd:annotation>
+			<xsd:documentation><![CDATA[
+  Element defining a custom converterr.
+      ]]></xsd:documentation>
+		</xsd:annotation>
+		<xsd:group ref="beanElementGroup" minOccurs="0" maxOccurs="1"/>
+		<xsd:attribute name="ref" type="xsd:string">
+			<xsd:annotation>
+				<xsd:documentation>
+					A reference to a custom converter.
+				</xsd:documentation>
+				<xsd:appinfo>
+					<tool:annotation kind="ref"/>
+				</xsd:appinfo>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:complexType>
+
+</xsd:schema>

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/config/MappingMongoConverterParserIntegrationTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2011-2012 the original author or authors.
+ * Copyright 2011-2013 the original author or authors.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,7 +15,7 @@
  */
 package org.springframework.data.mongodb.config;
 
-import static org.hamcrest.CoreMatchers.*;
+import static org.hamcrest.Matchers.*;
 import static org.junit.Assert.*;
 
 import java.util.Collections;
@@ -23,6 +23,7 @@ import java.util.Set;
 
 import org.junit.Before;
 import org.junit.Test;
+import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.support.DefaultListableBeanFactory;
 import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
 import org.springframework.core.convert.TypeDescriptor;
@@ -31,6 +32,7 @@ import org.springframework.core.convert.converter.GenericConverter;
 import org.springframework.core.io.ClassPathResource;
 import org.springframework.data.mongodb.core.convert.CustomConversions;
 import org.springframework.data.mongodb.core.mapping.Account;
+import org.springframework.data.mongodb.core.mapping.CamelCaseAbbreviatingFieldNamingStrategy;
 import org.springframework.data.mongodb.repository.Person;
 import org.springframework.stereotype.Component;
 
@@ -67,6 +69,20 @@ public class MappingMongoConverterParserIntegrationTests {
 		assertThat(conversions.hasCustomWriteTarget(Account.class), is(true));
 	}
 
+	/**
+	 * @see DATAMONGO-607
+	 */
+	@Test
+	public void activatesAbbreviatingPropertiesCorrectly() {
+
+		BeanDefinition definition = factory.getBeanDefinition("abbreviatingConverter.mappingContext");
+		Object value = definition.getPropertyValues().getPropertyValue("fieldNamingStrategy").getValue();
+
+		assertThat(value, is(instanceOf(BeanDefinition.class)));
+		BeanDefinition strategy = (BeanDefinition) value;
+		assertThat(strategy.getBeanClassName(), is(CamelCaseAbbreviatingFieldNamingStrategy.class.getName()));
+	}
+
 	@Component
 	public static class SampleConverter implements Converter<Person, DBObject> {
 		public DBObject convert(Person source) {

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/BasicMongoPersistentEntityUnitTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 by the original author(s).
+ * Copyright 2011-2013 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -15,9 +15,9 @@
  */
 package org.springframework.data.mongodb.core.mapping;
 
-import static org.mockito.Mockito.*;
 import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
 
 import org.junit.Test;
 import org.junit.runner.RunWith;

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/BasicMongoPersistentPropertyUnitTests.java

@@ -1,5 +1,5 @@
 /*
- * Copyright (c) 2011 by the original author(s).
+ * Copyright 2011-2013 by the original author(s).
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
@@ -19,10 +19,14 @@ import static org.hamcrest.CoreMatchers.*;
 import static org.junit.Assert.*;
 
 import java.lang.reflect.Field;
+import java.util.Locale;
 
 import org.junit.Before;
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
 import org.springframework.data.annotation.Id;
+import org.springframework.data.mapping.model.MappingException;
 import org.springframework.data.mapping.model.SimpleTypeHolder;
 import org.springframework.data.util.ClassTypeInformation;
 import org.springframework.util.ReflectionUtils;
@@ -36,6 +40,9 @@ public class BasicMongoPersistentPropertyUnitTests {
 
 	MongoPersistentEntity<Person> entity;
 
+	@Rule
+	public ExpectedException exception = ExpectedException.none();
+
 	@Before
 	public void setup() {
 		entity = new BasicMongoPersistentEntity<Person>(ClassTypeInformation.from(Person.class));
@@ -78,8 +85,45 @@ public class BasicMongoPersistentPropertyUnitTests {
 		assertThat(property.usePropertyAccess(), is(true));
 	}
 
+	/**
+	 * @see DATAMONGO-607
+	 */
+	@Test
+	public void usesCustomFieldNamingStrategyByDefault() throws Exception {
+
+		Field field = ReflectionUtils.findField(Person.class, "lastname");
+
+		MongoPersistentProperty property = new BasicMongoPersistentProperty(field, null, entity, new SimpleTypeHolder(),
+				UppercaseFieldNamingStrategy.INSTANCE);
+		assertThat(property.getFieldName(), is("LASTNAME"));
+
+		field = ReflectionUtils.findField(Person.class, "firstname");
+
+		property = new BasicMongoPersistentProperty(field, null, entity, new SimpleTypeHolder(),
+				UppercaseFieldNamingStrategy.INSTANCE);
+		assertThat(property.getFieldName(), is("foo"));
+	}
+
+	/**
+	 * @see DATAMONGO-607
+	 */
+	@Test
+	public void rejectsInvalidValueReturnedByFieldNamingStrategy() {
+
+		Field field = ReflectionUtils.findField(Person.class, "lastname");
+		MongoPersistentProperty property = new BasicMongoPersistentProperty(field, null, entity, new SimpleTypeHolder(),
+				InvalidFieldNamingStrategy.INSTANCE);
+
+		exception.expect(MappingException.class);
+		exception.expectMessage(InvalidFieldNamingStrategy.class.getName());
+		exception.expectMessage(property.toString());
+
+		property.getFieldName();
+	}
+
 	private MongoPersistentProperty getPropertyFor(Field field) {
-		return new BasicMongoPersistentProperty(field, null, entity, new SimpleTypeHolder());
+		return new BasicMongoPersistentProperty(field, null, entity, new SimpleTypeHolder(),
+				PropertyNameFieldNamingStrategy.INSTANCE);
 	}
 
 	class Person {
@@ -94,4 +138,22 @@ public class BasicMongoPersistentPropertyUnitTests {
 		@org.springframework.data.mongodb.core.mapping.Field(order = -20)
 		String ssn;
 	}
+
+	enum UppercaseFieldNamingStrategy implements FieldNamingStrategy {
+
+		INSTANCE;
+
+		public String getFieldName(MongoPersistentProperty property) {
+			return property.getName().toUpperCase(Locale.US);
+		}
+	}
+
+	enum InvalidFieldNamingStrategy implements FieldNamingStrategy {
+
+		INSTANCE;
+
+		public String getFieldName(MongoPersistentProperty property) {
+			return null;
+		}
+	}
 }

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/CamelCaseAbbreviatingFieldNamingStrategyUnitTests.java

@@ -0,0 +1,51 @@
+/*
+ * Copyright 2013 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.springframework.data.mongodb.core.mapping;
+
+import static org.hamcrest.CoreMatchers.*;
+import static org.junit.Assert.*;
+import static org.mockito.Mockito.*;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.runners.MockitoJUnitRunner;
+
+/**
+ * Unit tests for {@link CamelCaseAbbreviatingFieldNamingStrategy}.
+ * 
+ * @author Oliver Gierke
+ */
+@RunWith(MockitoJUnitRunner.class)
+public class CamelCaseAbbreviatingFieldNamingStrategyUnitTests {
+
+	FieldNamingStrategy strategy = new CamelCaseAbbreviatingFieldNamingStrategy();
+
+	@Mock
+	MongoPersistentProperty property;
+
+	@Test
+	public void foo() {
+		assertFieldNameForPropertyName("fooBar", "fb");
+		assertFieldNameForPropertyName("fooBARFooBar", "fbfb");
+	}
+
+	private void assertFieldNameForPropertyName(String propertyName, String fieldName) {
+
+		when(property.getName()).thenReturn(propertyName);
+		assertThat(strategy.getFieldName(property), is(fieldName));
+	}
+}

spring-data-mongodb/src/test/java/org/springframework/data/mongodb/core/mapping/MongoMappingContextUnitTests.java

@@ -21,9 +21,12 @@ import static org.junit.Assert.*;
 import java.lang.reflect.Field;
 import java.util.AbstractMap;
 import java.util.Collections;
+import java.util.Locale;
 import java.util.Map;
 
+import org.junit.Rule;
 import org.junit.Test;
+import org.junit.rules.ExpectedException;
 import org.junit.runner.RunWith;
 import org.mockito.Mock;
 import org.mockito.runners.MockitoJUnitRunner;
@@ -46,6 +49,9 @@ public class MongoMappingContextUnitTests {
 	@Mock
 	ApplicationContext applicationContext;
 
+	@Rule
+	public ExpectedException exception = ExpectedException.none();
+
 	@Test
 	public void addsSelfReferencingPersistentEntityCorrectly() throws Exception {
 
@@ -90,6 +96,41 @@ public class MongoMappingContextUnitTests {
 		assertThat(context.getPersistentEntity(AbstractMap.class), is(nullValue()));
 	}
 
+	/**
+	 * @see DATAMONGO-607
+	 */
+	@Test
+	public void populatesPersistentPropertyWithCustomFieldNamingStrategy() {
+
+		MongoMappingContext context = new MongoMappingContext();
+		context.setApplicationContext(applicationContext);
+		context.setFieldNamingStrategy(new FieldNamingStrategy() {
+
+			public String getFieldName(MongoPersistentProperty property) {
+				return property.getName().toUpperCase(Locale.US);
+			}
+		});
+
+		MongoPersistentEntity<?> entity = context.getPersistentEntity(Person.class);
+		assertThat(entity.getPersistentProperty("firstname").getFieldName(), is("FIRSTNAME"));
+	}
+
+	/**
+	 * @see DATAMONGO-607
+	 */
+	@Test
+	public void rejectsClassWithAmbiguousFieldMappings() {
+
+		exception.expect(MappingException.class);
+		exception.expectMessage("firstname");
+		exception.expectMessage("lastname");
+		exception.expectMessage("foo");
+
+		MongoMappingContext context = new MongoMappingContext();
+		context.setApplicationContext(applicationContext);
+		context.getPersistentEntity(InvalidPerson.class);
+	}
+
 	class ClassWithMultipleIdProperties {
 
 		@Id
@@ -102,4 +143,15 @@ public class MongoMappingContextUnitTests {
 
 		Map<String, SampleClass> children;
 	}
+
+	class Person {
+
+		String firstname, lastname;
+	}
+
+	class InvalidPerson {
+
+		@org.springframework.data.mongodb.core.mapping.Field("foo")
+		String firstname, lastname;
+	}
 }

spring-data-mongodb/src/test/resources/namespace/converter.xml

@@ -11,4 +11,6 @@
 	
 	<mongo:db-factory id="factory" />
 	
+	<mongo:mapping-converter id="abbreviatingConverter" abbreviate-field-names="true" />
+
 </beans>