diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoTemplate.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoTemplate.java
index 44ed454ad..b38b6e377 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoTemplate.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/MongoTemplate.java
@@ -50,6 +50,7 @@ import org.springframework.data.document.mongodb.convert.MappingMongoConverter;
 import org.springframework.data.document.mongodb.convert.MongoConverter;
 import org.springframework.data.document.mongodb.convert.SimpleMongoConverter;
 import org.springframework.data.document.mongodb.index.IndexDefinition;
+import org.springframework.data.document.mongodb.mapping.MongoMappingContext;
 import org.springframework.data.document.mongodb.mapping.MongoPersistentEntity;
 import org.springframework.data.document.mongodb.mapping.MongoPersistentProperty;
 import org.springframework.data.document.mongodb.mapping.event.AfterConvertEvent;
@@ -58,6 +59,7 @@ import org.springframework.data.document.mongodb.mapping.event.AfterSaveEvent;
 import org.springframework.data.document.mongodb.mapping.event.BeforeConvertEvent;
 import org.springframework.data.document.mongodb.mapping.event.BeforeSaveEvent;
 import org.springframework.data.document.mongodb.mapping.event.MongoMappingEvent;
+import org.springframework.data.document.mongodb.mapping.event.MongoMappingEventPublisher;
 import org.springframework.data.document.mongodb.query.Query;
 import org.springframework.data.document.mongodb.query.QueryMapper;
 import org.springframework.data.document.mongodb.query.Update;
@@ -69,7 +71,7 @@ import org.springframework.util.Assert;
 
 /**
  * Primary implementation of {@link MongoOperations}.
- * 
+ *
  * @author Thomas Risberg
  * @author Graeme Rocher
  * @author Mark Pollack
@@ -108,7 +110,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 
 	/**
 	 * Constructor used for a basic template configuration
-	 * 
+	 *
 	 * @param mongo
 	 * @param databaseName
 	 */
@@ -119,7 +121,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	/**
 	 * Constructor used for a template configuration with a custom
 	 * {@link org.springframework.data.document.mongodb.convert.MongoConverter}
-	 * 
+	 *
 	 * @param mongo
 	 * @param databaseName
 	 * @param mongoConverter
@@ -130,7 +132,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 
 	/**
 	 * Constructor used for a basic template configuration
-	 * 
+	 *
 	 * @param mongoDbFactory
 	 */
 	public MongoTemplate(MongoDbFactory mongoDbFactory) {
@@ -139,16 +141,32 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 
 	/**
 	 * Constructor used for a basic template configuration
-	 * 
+	 *
 	 * @param mongoDbFactory
 	 * @param mongoConverter
 	 */
 	public MongoTemplate(MongoDbFactory mongoDbFactory, MongoConverter mongoConverter) {
+		this(mongoDbFactory, mongoConverter, null, null);
+	}
 
+	/**
+	 * Constructor used for a template configuration with a custom {@link MongoConverter} and with a specific
+	 * {@link com.mongodb.WriteConcern} to be used for all database write operations
+	 *
+	 * @param mongoDbFactory
+	 * @param mongoConverter
+	 * @param writeConcern
+	 * @param writeResultChecking
+	 */
+	MongoTemplate(MongoDbFactory mongoDbFactory,
+								MongoConverter mongoConverter,
+								WriteConcern writeConcern,
+								WriteResultChecking writeResultChecking) {
 		Assert.notNull(mongoDbFactory);
 
 		this.mongoDbFactory = mongoDbFactory;
 		this.mongoConverter = mongoConverter == null ? getDefaultMongoConverter() : mongoConverter;
+		this.writeConcern = writeConcern;
 
 		if (this.mongoConverter instanceof MappingMongoConverter) {
 			initializeMappingMongoConverter((MappingMongoConverter) this.mongoConverter);
@@ -157,6 +175,14 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 		this.mappingContext = this.mongoConverter.getMappingContext();
 		this.mapper = new QueryMapper(this.mongoConverter);
 
+		if (writeResultChecking != null) {
+			this.writeResultChecking = writeResultChecking;
+		}
+
+		if (this.mappingContext instanceof MongoMappingContext) {
+			this.eventPublisher = new MongoMappingEventPublisher((MongoMappingContext) mappingContext, mongoDbFactory);
+		}
+
 	}
 
 	private final MongoConverter getDefaultMongoConverter() {
@@ -172,7 +198,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 
 	/**
 	 * Returns the default {@link org.springframework.data.document.mongodb.convert.MongoConverter}.
-	 * 
+	 *
 	 * @return
 	 */
 	public MongoConverter getConverter() {
@@ -181,7 +207,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 
 	/**
 	 * Returns the {@link org.springframework.data.document.mongodb.MongoDbFactory}.
-	 * 
+	 *
 	 * @return
 	 */
 	public MongoDbFactory getDbFactory() {
@@ -260,6 +286,71 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 		}
 	}
 
+	/**
+	 * Central callback executing method to do queries against the datastore that requires reading a single object from a
+	 * collection of objects. It will take the following steps
+	 * <ol>
+	 * <li>Execute the given {@link ConnectionCallback} for a {@link DBObject}.</li>
+	 * <li>Apply the given {@link DbObjectCallback} to each of the {@link DBObject}s to obtain the result.</li>
+	 * <ol>
+	 *
+	 * @param <T>
+	 * @param collectionCallback the callback to retrieve the {@link DBObject} with
+	 * @param objectCallback		 the {@link DbObjectCallback} to transform {@link DBObject}s into the actual domain type
+	 * @param collectionName		 the collection to be queried
+	 * @return
+	 */
+	private <T> T execute(CollectionCallback<DBObject> collectionCallback, DbObjectCallback<T> objectCallback,
+												String collectionName) {
+
+		try {
+			T result = objectCallback.doWith(collectionCallback.doInCollection(getCollection(collectionName)));
+			return result;
+		} catch (RuntimeException e) {
+			throw potentiallyConvertRuntimeException(e);
+		}
+	}
+
+	/**
+	 * Central callback executing method to do queries against the datastore that requires reading a collection of
+	 * objects. It will take the following steps
+	 * <ol>
+	 * <li>Execute the given {@link ConnectionCallback} for a {@link DBCursor}.</li>
+	 * <li>Prepare that {@link DBCursor} with the given {@link CursorPreparer} (will be skipped if {@link CursorPreparer}
+	 * is {@literal null}</li>
+	 * <li>Iterate over the {@link DBCursor} and applies the given {@link DbObjectCallback} to each of the
+	 * {@link DBObject}s collecting the actual result {@link List}.</li>
+	 * <ol>
+	 *
+	 * @param <T>
+	 * @param collectionCallback the callback to retrieve the {@link DBCursor} with
+	 * @param preparer					 the {@link CursorPreparer} to potentially modify the {@link DBCursor} before ireating over it
+	 * @param objectCallback		 the {@link DbObjectCallback} to transform {@link DBObject}s into the actual domain type
+	 * @param collectionName		 the collection to be queried
+	 * @return
+	 */
+	private <T> List<T> executeEach(CollectionCallback<DBCursor> collectionCallback, CursorPreparer preparer,
+																	DbObjectCallback<T> objectCallback, String collectionName) {
+
+		try {
+			DBCursor cursor = collectionCallback.doInCollection(getCollection(collectionName));
+
+			if (preparer != null) {
+				cursor = preparer.prepare(cursor);
+			}
+
+			List<T> result = new ArrayList<T>();
+
+			for (DBObject object : cursor) {
+				result.add(objectCallback.doWith(object));
+			}
+
+			return result;
+		} catch (RuntimeException e) {
+			throw potentiallyConvertRuntimeException(e);
+		}
+	}
+
 	/* (non-Javadoc)
 	 * @see org.springframework.data.document.mongodb.MongoOperations#executeInSession(org.springframework.data.document.mongodb.DBCallback)
 	 */
@@ -681,7 +772,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	}
 
 	protected WriteResult doUpdate(final String collectionName, final Query query, final Update update,
-			final Class<?> entityClass, final boolean upsert, final boolean multi) {
+																 final Class<?> entityClass, final boolean upsert, final boolean multi) {
 
 		return execute(collectionName, new CollectionCallback<WriteResult>() {
 			public WriteResult doInCollection(DBCollection collection) throws MongoException, DataAccessException {
@@ -808,7 +899,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 
 	/**
 	 * Create the specified collection using the provided options
-	 * 
+	 *
 	 * @param collectionName
 	 * @param collectionOptions
 	 * @return the collection that was created
@@ -827,15 +918,11 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	 * Map the results of an ad-hoc query on the default MongoDB collection to an object using the template's converter
 	 * <p/>
 	 * The query document is specified as a standard DBObject and so is the fields specification.
-	 * 
-	 * @param collectionName
-	 *          name of the collection to retrieve the objects from
-	 * @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 targetClass
-	 *          the parameterized type of the returned list.
+	 *
+	 * @param collectionName name of the collection to retrieve the objects from
+	 * @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 targetClass		the parameterized type of the returned list.
 	 * @return the List of converted objects.
 	 */
 	protected <T> T doFindOne(String collectionName, DBObject query, DBObject fields, Class<T> targetClass) {
@@ -856,22 +943,17 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	 * The query document is specified as a standard DBObject and so is the fields specification.
 	 * <p/>
 	 * Can be overridden by subclasses.
-	 * 
-	 * @param collectionName
-	 *          name of the collection to retrieve the objects from
-	 * @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 targetClass
-	 *          the parameterized type of the returned list.
-	 * @param preparer
-	 *          allows for customization of the DBCursor used when iterating over the result set, (apply limits, skips and
-	 *          so on).
+	 *
+	 * @param collectionName name of the collection to retrieve the objects from
+	 * @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 targetClass		the parameterized type of the returned list.
+	 * @param preparer			 allows for customization of the DBCursor used when iterating over the result set, (apply limits, skips and
+	 *                       so on).
 	 * @return the List of converted objects.
 	 */
 	protected <T> List<T> doFind(String collectionName, DBObject query, DBObject fields, Class<T> targetClass,
-			CursorPreparer preparer) {
+															 CursorPreparer preparer) {
 		MongoPersistentEntity<?> entity = mappingContext.getPersistentEntity(targetClass);
 		if (LOGGER.isDebugEnabled()) {
 			LOGGER.debug("find using query: " + query + " fields: " + fields + " for class: " + targetClass
@@ -885,17 +967,11 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	 * Map the results of an ad-hoc query on the default MongoDB collection to a List using the template's converter.
 	 * <p/>
 	 * The query document is specified as a standard DBObject and so is the fields specification.
-	 * 
-	 * @param collectionName
-	 *          name of the collection to retrieve the objects from
-	 * @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 targetClass
-	 *          the parameterized type of the returned list.
-	 * @param reader
-	 *          the MongoReader to convert from DBObject to an object.
+	 *
+	 * @param collectionName name of the collection to retrieve the objects from
+	 * @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 targetClass		the parameterized type of the returned list.
 	 * @return the List of converted objects.
 	 */
 	protected <T> List<T> doFind(String collectionName, DBObject query, DBObject fields, Class<T> targetClass) {
@@ -930,19 +1006,14 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	 * The first document that matches the query is returned and also removed from the collection in the database.
 	 * <p/>
 	 * The query document is specified as a standard DBObject and so is the fields specification.
-	 * 
-	 * @param collectionName
-	 *          name of the collection to retrieve the objects from
-	 * @param query
-	 *          the query document that specifies the criteria used to find a record
-	 * @param targetClass
-	 *          the parameterized type of the returned list.
-	 * @param reader
-	 *          the MongoReader to convert from DBObject to an object.
+	 *
+	 * @param collectionName name of the collection to retrieve the objects from
+	 * @param query					the query document that specifies the criteria used to find a record
+	 * @param targetClass		the parameterized type of the returned list.
 	 * @return the List of converted objects.
 	 */
 	protected <T> T doFindAndRemove(String collectionName, DBObject query, DBObject fields, DBObject sort,
-			Class<T> targetClass) {
+																	Class<T> targetClass) {
 		MongoReader<? super T> readerToUse = this.mongoConverter;
 		if (LOGGER.isDebugEnabled()) {
 			LOGGER.debug("findAndRemove using query: " + query + " fields: " + fields + " sort: " + sort + " for class: "
@@ -979,7 +1050,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 
 	/**
 	 * Populates the id property of the saved object, if it's not set already.
-	 * 
+	 *
 	 * @param savedObject
 	 * @param id
 	 */
@@ -1165,7 +1236,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	/**
 	 * Tries to convert the given {@link RuntimeException} into a {@link DataAccessException} but returns the original
 	 * exception if the conversation failed. Thus allows safe rethrowing of the return value.
-	 * 
+	 *
 	 * @param ex
 	 * @return
 	 */
@@ -1182,7 +1253,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	/**
 	 * Simple {@link CollectionCallback} that takes a query {@link DBObject} plus an optional fields specification
 	 * {@link DBObject} and executes that against the {@link DBCollection}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 * @author Thomas Risberg
 	 */
@@ -1216,7 +1287,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	/**
 	 * Simple {@link CollectionCallback} that takes a query {@link DBObject} plus an optional fields specification
 	 * {@link DBObject} and executes that against the {@link DBCollection}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 * @author Thomas Risberg
 	 */
@@ -1247,7 +1318,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	/**
 	 * Simple {@link CollectionCallback} that takes a query {@link DBObject} plus an optional fields specification
 	 * {@link DBObject} and executes that against the {@link DBCollection}.
-	 * 
+	 *
 	 * @author Thomas Risberg
 	 */
 	private static class FindAndRemoveCallback implements CollectionCallback<DBObject> {
@@ -1271,7 +1342,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 
 	/**
 	 * Simple internal callback to allow operations on a {@link DBObject}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 */
 
@@ -1283,7 +1354,7 @@ public class MongoTemplate implements MongoOperations, ApplicationEventPublisher
 	/**
 	 * Simple {@link DbObjectCallback} that will transform {@link DBObject} into the given target type using the given
 	 * {@link MongoReader}.
-	 * 
+	 *
 	 * @author Oliver Gierke
 	 */
 	private class ReadDbObjectCallback<T> implements DbObjectCallback<T> {
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/AbstractMongoConfiguration.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/AbstractMongoConfiguration.java
index 60c1255dc..ef3183d40 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/AbstractMongoConfiguration.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/AbstractMongoConfiguration.java
@@ -18,12 +18,15 @@ package org.springframework.data.document.mongodb.config;
 import java.util.HashSet;
 import java.util.Set;
 
+import com.mongodb.Mongo;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.context.annotation.Bean;
 import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider;
 import org.springframework.context.annotation.Configuration;
 import org.springframework.core.type.filter.AnnotationTypeFilter;
 import org.springframework.data.annotation.Persistent;
+import org.springframework.data.document.mongodb.MongoDbFactory;
+import org.springframework.data.document.mongodb.MongoDbFactoryBean;
 import org.springframework.data.document.mongodb.MongoTemplate;
 import org.springframework.data.document.mongodb.convert.MappingMongoConverter;
 import org.springframework.data.document.mongodb.mapping.Document;
@@ -33,8 +36,6 @@ import org.springframework.data.mapping.context.MappingContextAwareBeanPostProce
 import org.springframework.util.ClassUtils;
 import org.springframework.util.StringUtils;
 
-import com.mongodb.Mongo;
-
 @Configuration
 public abstract class AbstractMongoConfiguration {
 
@@ -44,6 +45,15 @@ public abstract class AbstractMongoConfiguration {
 	@Bean
 	public abstract MongoTemplate mongoTemplate() throws Exception;
 
+	public String defaultDatabaseName() {
+		return "db";
+	}
+
+	@Bean
+	public MongoDbFactory mongoDbFactory() throws Exception {
+		return new MongoDbFactoryBean(mongo(), defaultDatabaseName());
+	}
+
 	public String getMappingBasePackage() {
 		return "";
 	}
@@ -53,15 +63,13 @@ public abstract class AbstractMongoConfiguration {
 		MongoMappingContext mappingContext = new MongoMappingContext();
 		String basePackage = getMappingBasePackage();
 		if (StringUtils.hasText(basePackage)) {
-			ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(
-					false);
+			ClassPathScanningCandidateComponentProvider componentProvider = new ClassPathScanningCandidateComponentProvider(false);
 			componentProvider.addIncludeFilter(new AnnotationTypeFilter(Document.class));
 			componentProvider.addIncludeFilter(new AnnotationTypeFilter(Persistent.class));
 
 			Set<Class<?>> initialEntitySet = new HashSet<Class<?>>();
 			for (BeanDefinition candidate : componentProvider.findCandidateComponents(basePackage)) {
-				initialEntitySet.add(ClassUtils.forName(candidate.getBeanClassName(), mappingContext.getClass()
-						.getClassLoader()));
+				initialEntitySet.add(ClassUtils.forName(candidate.getBeanClassName(), mappingContext.getClass().getClassLoader()));
 			}
 			mappingContext.setInitialEntitySet(initialEntitySet);
 		}
@@ -78,7 +86,7 @@ public abstract class AbstractMongoConfiguration {
 
 	/**
 	 * Hook that allows post-processing after the MappingMongoConverter has been successfully created.
-	 * 
+	 *
 	 * @param converter
 	 */
 	protected void afterMappingMongoConverterCreation(MappingMongoConverter converter) {
@@ -91,10 +99,8 @@ public abstract class AbstractMongoConfiguration {
 		return bpp;
 	}
 
-	@Bean
-	MongoPersistentEntityIndexCreator mongoPersistentEntityIndexCreator() throws Exception {
-		MongoPersistentEntityIndexCreator indexCreator = new MongoPersistentEntityIndexCreator(mongoMappingContext(),
-				mongoTemplate());
+	@Bean MongoPersistentEntityIndexCreator mongoPersistentEntityIndexCreator() throws Exception {
+		MongoPersistentEntityIndexCreator indexCreator = new MongoPersistentEntityIndexCreator(mongoMappingContext(), mongoDbFactory());
 		return indexCreator;
 	}
 }
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/BeanNames.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/BeanNames.java
new file mode 100644
index 000000000..daa7820c9
--- /dev/null
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/BeanNames.java
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2011 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.
+ * 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.document.mongodb.config;
+
+/**
+ * @author Jon Brisbin <jbrisbin@vmware.com>
+ */
+public abstract class BeanNames {
+
+	static final String MAPPING_CONTEXT = "mappingContext";
+	static final String INDEX_HELPER = "indexCreationHelper";
+	static final String MONGO = "mongo";
+	static final String DB_FACTORY = "mongoDbFactory";
+	static final String POST_PROCESSOR = "mappingContextAwareBeanPostProcessor";
+
+}
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MappingMongoConverterParser.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MappingMongoConverterParser.java
index 21fe7deeb..234ef8b2d 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MappingMongoConverterParser.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MappingMongoConverterParser.java
@@ -16,23 +16,21 @@
 
 package org.springframework.data.document.mongodb.config;
 
+import static org.springframework.data.document.mongodb.config.BeanNames.*;
+
 import java.util.List;
 import java.util.Set;
 
 import org.springframework.beans.BeanMetadataElement;
-import org.springframework.beans.MutablePropertyValues;
 import org.springframework.beans.factory.BeanDefinitionStoreException;
 import org.springframework.beans.factory.NoSuchBeanDefinitionException;
 import org.springframework.beans.factory.config.BeanDefinition;
 import org.springframework.beans.factory.config.BeanDefinitionHolder;
-import org.springframework.beans.factory.config.RuntimeBeanNameReference;
 import org.springframework.beans.factory.config.RuntimeBeanReference;
-import org.springframework.beans.factory.parsing.CompositeComponentDefinition;
 import org.springframework.beans.factory.support.AbstractBeanDefinition;
 import org.springframework.beans.factory.support.BeanDefinitionBuilder;
 import org.springframework.beans.factory.support.BeanDefinitionRegistry;
 import org.springframework.beans.factory.support.ManagedList;
-import org.springframework.beans.factory.support.ManagedMap;
 import org.springframework.beans.factory.support.ManagedSet;
 import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
 import org.springframework.beans.factory.xml.ParserContext;
@@ -54,12 +52,6 @@ import org.w3c.dom.Element;
  */
 public class MappingMongoConverterParser extends AbstractBeanDefinitionParser {
 
-	static final String MAPPING_CONTEXT = "mappingContext";
-
-	private static final String INDEX_HELPER = "indexCreationHelper";
-	private static final String TEMPLATE = "mongoTemplate";
-	private static final String POST_PROCESSOR = "mappingContextAwareBeanPostProcessor";
-
 	private static final String BASE_PACKAGE = "base-package";
 
 	@Override
@@ -101,17 +93,21 @@ public class MappingMongoConverterParser extends AbstractBeanDefinitionParser {
 
 		// Need a reference to a Mongo instance
 		String mongoRef = element.getAttribute("mongo-ref");
-		converterBuilder.addPropertyReference("mongo", StringUtils.hasText(mongoRef) ? mongoRef : "mongo");
+		if (!StringUtils.hasText(mongoRef)) {
+			mongoRef = MONGO;
+		}
+		converterBuilder.addPropertyReference("mongo", mongoRef);
 
 		try {
 			registry.getBeanDefinition(INDEX_HELPER);
 		} catch (NoSuchBeanDefinitionException ignored) {
-			String templateRef = element.getAttribute("mongo-template-ref");
-			BeanDefinitionBuilder indexHelperBuilder = BeanDefinitionBuilder
-					.genericBeanDefinition(MongoPersistentEntityIndexCreator.class);
+			String dbFactoryRef = element.getAttribute("db-factory-ref");
+			if (!StringUtils.hasText(dbFactoryRef)) {
+				dbFactoryRef = DB_FACTORY;
+			}
+			BeanDefinitionBuilder indexHelperBuilder = BeanDefinitionBuilder.genericBeanDefinition(MongoPersistentEntityIndexCreator.class);
 			indexHelperBuilder.addConstructorArgValue(new RuntimeBeanReference(ctxRef));
-			indexHelperBuilder.addConstructorArgValue(new RuntimeBeanReference(StringUtils.hasText(templateRef) ? templateRef
-					: TEMPLATE));
+			indexHelperBuilder.addConstructorArgValue(new RuntimeBeanReference(dbFactoryRef));
 			registry.registerBeanDefinition(INDEX_HELPER, indexHelperBuilder.getBeanDefinition());
 		}
 
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoDbFactoryParser.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoDbFactoryParser.java
new file mode 100644
index 000000000..ab40730fc
--- /dev/null
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoDbFactoryParser.java
@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2011 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.
+ * 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.document.mongodb.config;
+
+import static org.springframework.data.document.mongodb.config.BeanNames.*;
+
+import org.springframework.beans.factory.BeanDefinitionStoreException;
+import org.springframework.beans.factory.config.RuntimeBeanReference;
+import org.springframework.beans.factory.support.AbstractBeanDefinition;
+import org.springframework.beans.factory.support.BeanDefinitionBuilder;
+import org.springframework.beans.factory.support.BeanDefinitionRegistry;
+import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser;
+import org.springframework.beans.factory.xml.ParserContext;
+import org.springframework.data.document.mongodb.MongoDbFactoryBean;
+import org.springframework.data.document.mongodb.MongoFactoryBean;
+import org.springframework.util.StringUtils;
+import org.springframework.util.xml.DomUtils;
+import org.w3c.dom.Element;
+
+/**
+ * @author Jon Brisbin <jbrisbin@vmware.com>
+ */
+public class MongoDbFactoryParser extends AbstractBeanDefinitionParser {
+
+	@Override
+	protected String resolveId(Element element, AbstractBeanDefinition definition, ParserContext parserContext) throws BeanDefinitionStoreException {
+		String id = element.getAttribute("id");
+		if (!StringUtils.hasText(id)) {
+			id = DB_FACTORY;
+		}
+		return id;
+	}
+
+	@Override
+	protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) {
+		BeanDefinitionRegistry registry = parserContext.getRegistry();
+		BeanDefinitionBuilder dbFactoryBuilder = BeanDefinitionBuilder.genericBeanDefinition(MongoDbFactoryBean.class);
+
+		// Host/Port used in this and the mongoFactory
+		String host = element.getAttribute("host");
+		if (!StringUtils.hasText(host)) {
+			host = "localhost";
+		}
+		dbFactoryBuilder.addPropertyValue("host", host);
+		String port = element.getAttribute("port");
+		if (!StringUtils.hasText(port)) {
+			port = "27017";
+		}
+		dbFactoryBuilder.addPropertyValue("port", port);
+
+		// Username/Password not always used (but is in CloudFoundry
+		String username = element.getAttribute("username");
+		if (StringUtils.hasText(username)) {
+			dbFactoryBuilder.addPropertyValue("username", username);
+		}
+		String password = element.getAttribute("password");
+		if (StringUtils.hasText(password)) {
+			dbFactoryBuilder.addPropertyValue("password", password);
+		}
+
+		// Database name
+		String db = element.getAttribute("db");
+		if (!StringUtils.hasText(db)) {
+			db = "db";
+		}
+		dbFactoryBuilder.addPropertyValue("databaseName", db);
+
+		// Create or reference a MongoFactory instance.
+		// Also respect embedded "mongo:mongo" definitions.
+		String mongoRef = element.getAttribute("mongo-ref");
+		if (!StringUtils.hasText(mongoRef)) {
+			BeanDefinitionBuilder mongoBuilder = BeanDefinitionBuilder.genericBeanDefinition(MongoFactoryBean.class);
+			Element mongoEl = DomUtils.getChildElementByTagName(element, "mongo");
+			if (null != mongoEl) {
+				String overrideHost = mongoEl.getAttribute("host");
+				mongoBuilder.addPropertyValue("host", (overrideHost != null ? overrideHost : host));
+				String overridePort = mongoEl.getAttribute("port");
+				mongoBuilder.addPropertyValue("port", (overridePort != null ? overridePort : port));
+				new MongoParser().parseOptions(parserContext, mongoEl, mongoBuilder);
+			}
+			registry.registerBeanDefinition(MONGO, mongoBuilder.getBeanDefinition());
+			mongoRef = MONGO;
+		}
+		dbFactoryBuilder.addPropertyValue("mongo", new RuntimeBeanReference(mongoRef));
+
+		return dbFactoryBuilder.getRawBeanDefinition();
+	}
+
+}
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoParser.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoParser.java
index 4d029d6e1..2b9989a3a 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoParser.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoParser.java
@@ -29,7 +29,7 @@ import org.w3c.dom.Element;
 
 /**
  * Parser for &lt;mongo;gt; definitions. If no name
- * 
+ *
  * @author Mark Pollack
  */
 public class MongoParser extends AbstractSingleBeanDefinitionParser {
@@ -51,12 +51,12 @@ public class MongoParser extends AbstractSingleBeanDefinitionParser {
 
 	/**
 	 * Parses the options sub-element. Populates the given attribute factory with the proper attributes.
-	 * 
+	 *
 	 * @param element
 	 * @param attrBuilder
 	 * @return true if parsing actually occured, false otherwise
 	 */
-	private boolean parseOptions(ParserContext parserContext, Element element, BeanDefinitionBuilder mongoBuilder) {
+	boolean parseOptions(ParserContext parserContext, Element element, BeanDefinitionBuilder mongoBuilder) {
 		Element optionsElement = DomUtils.getChildElementByTagName(element, "options");
 		if (optionsElement == null)
 			return false;
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoRepositoryConfigParser.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoRepositoryConfigParser.java
index 94f39a1f2..7c6562028 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoRepositoryConfigParser.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoRepositoryConfigParser.java
@@ -32,7 +32,7 @@ import org.w3c.dom.Element;
 public class MongoRepositoryConfigParser extends
 		AbstractRepositoryConfigDefinitionParser<SimpleMongoRepositoryConfiguration, MongoRepositoryConfiguration> {
 
-	private static final String MAPPING_CONTEXT_DEFAULT = MappingMongoConverterParser.MAPPING_CONTEXT;
+	private static final String MAPPING_CONTEXT_DEFAULT = BeanNames.MAPPING_CONTEXT;
 
 	/*
 	* (non-Javadoc)
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoRepositoryNamespaceHandler.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoRepositoryNamespaceHandler.java
index 0dc275879..875ea3070 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoRepositoryNamespaceHandler.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoRepositoryNamespaceHandler.java
@@ -19,7 +19,7 @@ import org.springframework.beans.factory.xml.NamespaceHandlerSupport;
 
 /**
  * {@link org.springframework.beans.factory.xml.NamespaceHandler} for Mongo DB based repositories.
- * 
+ *
  * @author Oliver Gierke
  */
 public class MongoRepositoryNamespaceHandler extends NamespaceHandlerSupport {
@@ -34,6 +34,7 @@ public class MongoRepositoryNamespaceHandler extends NamespaceHandlerSupport {
 		registerBeanDefinitionParser("repositories", new MongoRepositoryConfigParser());
 		registerBeanDefinitionParser("mapping-converter", new MappingMongoConverterParser());
 		registerBeanDefinitionParser("mongo", new MongoParser());
+		registerBeanDefinitionParser("db-factory", new MongoDbFactoryParser());
 		registerBeanDefinitionParser("jmx", new MongoJmxParser());
 	}
 }
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/MongoPersistentEntityIndexCreator.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/MongoPersistentEntityIndexCreator.java
index 4bb80be71..8269fb346 100644
--- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/MongoPersistentEntityIndexCreator.java
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/MongoPersistentEntityIndexCreator.java
@@ -22,16 +22,12 @@ import java.util.Set;
 import java.util.concurrent.ConcurrentHashMap;
 
 import com.mongodb.BasicDBObject;
-import com.mongodb.DBCollection;
 import com.mongodb.DBObject;
-import com.mongodb.MongoException;
 import com.mongodb.util.JSON;
 import org.apache.commons.logging.Log;
 import org.apache.commons.logging.LogFactory;
 import org.springframework.context.ApplicationListener;
-import org.springframework.dao.DataAccessException;
-import org.springframework.data.document.mongodb.CollectionCallback;
-import org.springframework.data.document.mongodb.MongoTemplate;
+import org.springframework.data.document.mongodb.MongoDbFactory;
 import org.springframework.data.document.mongodb.index.CompoundIndex;
 import org.springframework.data.document.mongodb.index.CompoundIndexes;
 import org.springframework.data.document.mongodb.index.GeoSpatialIndexed;
@@ -47,7 +43,7 @@ import org.springframework.util.StringUtils;
 /**
  * Component that inspects {@link BasicMongoPersistentEntity} instances contained in the given
  * {@link MongoMappingContext} for indexing metadata and ensures the indexes to be available.
- * 
+ *
  * @author Jon Brisbin <jbrisbin@vmware.com>
  * @author Oliver Gierke
  */
@@ -57,13 +53,13 @@ public class MongoPersistentEntityIndexCreator implements ApplicationListener<Ma
 
 	private Set<Class<?>> classesSeen = Collections.newSetFromMap(new ConcurrentHashMap<Class<?>, Boolean>());
 
-	private final MongoTemplate mongoTemplate;
+	private final MongoDbFactory mongoDbFactory;
 
-	public MongoPersistentEntityIndexCreator(MongoMappingContext mappingContext, MongoTemplate mongoTemplate) {
+	public MongoPersistentEntityIndexCreator(MongoMappingContext mappingContext, MongoDbFactory mongoDbFactory) {
 
-		Assert.notNull(mongoTemplate);
+		Assert.notNull(mongoDbFactory);
 		Assert.notNull(mappingContext);
-		this.mongoTemplate = mongoTemplate;
+		this.mongoDbFactory = mongoDbFactory;
 
 		for (MongoPersistentEntity<?> entity : mappingContext.getPersistentEntities()) {
 			checkForIndexes(entity);
@@ -131,7 +127,7 @@ public class MongoPersistentEntityIndexCreator implements ApplicationListener<Ma
 						indexObject.withMin(index.min()).withMax(index.max());
 
 						String collection = StringUtils.hasText(index.collection()) ? index.collection() : entity.getCollection();
-						mongoTemplate.ensureIndex(collection, indexObject);
+						mongoDbFactory.getDb().getCollection(collection).ensureIndex(indexObject.getIndexKeys(), indexObject.getIndexOptions());
 
 						if (log.isDebugEnabled()) {
 							log.debug(String.format("Created %s for entity %s in collection %s! ", indexObject, entity.getType(),
@@ -147,24 +143,20 @@ public class MongoPersistentEntityIndexCreator implements ApplicationListener<Ma
 	}
 
 	protected void ensureIndex(String collection, final String name, final String def, final IndexDirection direction,
-			final boolean unique, final boolean dropDups, final boolean sparse) {
-		mongoTemplate.execute(collection, new CollectionCallback<Object>() {
-			public Object doInCollection(DBCollection collection) throws MongoException, DataAccessException {
-				DBObject defObj;
-				if (null != def) {
-					defObj = (DBObject) JSON.parse(def);
-				} else {
-					defObj = new BasicDBObject();
-					defObj.put(name, (direction == IndexDirection.ASCENDING ? 1 : -1));
-				}
-				DBObject opts = new BasicDBObject();
-				// opts.put("name", name + "_idx");
-				opts.put("dropDups", dropDups);
-				opts.put("sparse", sparse);
-				opts.put("unique", unique);
-				collection.ensureIndex(defObj, opts);
-				return null;
-			}
-		});
+														 final boolean unique, final boolean dropDups, final boolean sparse) {
+		DBObject defObj;
+		if (null != def) {
+			defObj = (DBObject) JSON.parse(def);
+		} else {
+			defObj = new BasicDBObject();
+			defObj.put(name, (direction == IndexDirection.ASCENDING ? 1 : -1));
+		}
+		DBObject opts = new BasicDBObject();
+		// opts.put("name", name + "_idx");
+		opts.put("dropDups", dropDups);
+		opts.put("sparse", sparse);
+		opts.put("unique", unique);
+		mongoDbFactory.getDb().getCollection(collection).ensureIndex(defObj, opts);
 	}
+
 }
diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/event/MongoMappingEventPublisher.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/event/MongoMappingEventPublisher.java
new file mode 100644
index 000000000..d68641934
--- /dev/null
+++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/event/MongoMappingEventPublisher.java
@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2011 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.
+ * 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.document.mongodb.mapping.event;
+
+import org.springframework.context.ApplicationEvent;
+import org.springframework.context.ApplicationEventPublisher;
+import org.springframework.data.document.mongodb.MongoDbFactory;
+import org.springframework.data.document.mongodb.mapping.MongoMappingContext;
+import org.springframework.data.document.mongodb.mapping.MongoPersistentEntityIndexCreator;
+import org.springframework.data.mapping.event.MappingContextEvent;
+
+/**
+ * @author Jon Brisbin <jbrisbin@vmware.com>
+ */
+public class MongoMappingEventPublisher implements ApplicationEventPublisher {
+
+	private MongoPersistentEntityIndexCreator indexCreator;
+
+	public MongoMappingEventPublisher(MongoMappingContext mappingContext, MongoDbFactory mongoDbFactory) {
+		indexCreator = new MongoPersistentEntityIndexCreator(mappingContext, mongoDbFactory);
+	}
+
+	public void publishEvent(ApplicationEvent event) {
+		if (event instanceof MappingContextEvent) {
+			indexCreator.onApplicationEvent((MappingContextEvent<?, ?>) event);
+		}
+	}
+
+}
diff --git a/spring-data-mongodb/src/main/resources/org/springframework/data/document/mongodb/config/spring-mongo-1.0.xsd b/spring-data-mongodb/src/main/resources/org/springframework/data/document/mongodb/config/spring-mongo-1.0.xsd
index 09b59efc4..59f3880b6 100644
--- a/spring-data-mongodb/src/main/resources/org/springframework/data/document/mongodb/config/spring-mongo-1.0.xsd
+++ b/spring-data-mongodb/src/main/resources/org/springframework/data/document/mongodb/config/spring-mongo-1.0.xsd
@@ -1,311 +1,379 @@
 <?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"
-            xsi:schemaLocation="http://www.springframework.org/schema/beans 
+						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"
+						xsi:schemaLocation="http://www.springframework.org/schema/beans
             http://www.springframework.org/schema/beans/spring-beans-2.5.xsd">
-            
 
-  <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"
-              schemaLocation="http://www.springframework.org/schema/context/spring-context.xsd"/>
-  <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">
-    <xsd:annotation>
-      <xsd:documentation source="org.springframework.data.document.mongodb.MongoFactoryBean"><![CDATA[
+	<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"
+							schemaLocation="http://www.springframework.org/schema/context/spring-context.xsd"/>
+	<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.document.mongodb.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:complexType>
-      <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:sequence minOccurs="0" maxOccurs="1">
-        <xsd:element name="replica-set" type="replicaSetType">
-          <xsd:annotation>
-            <xsd:documentation><![CDATA[
-The Mongo Replica set database addresses
-							]]></xsd:documentation>
-            <xsd:appinfo>
-              <tool:annotation>
-                <tool:exports type="com.mongodb.MongoOptions"/>
-              </tool:annotation>
-            </xsd:appinfo>
-          </xsd:annotation>
-        </xsd:element>
-      </xsd:sequence>
-      -->
+			<xsd:appinfo>
+				<tool:annotation>
+					<tool:exports type="com.mongodb.Mongo"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+	</xsd:element>
 
-      <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[
+	<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:sequence minOccurs="0" maxOccurs="1">
+				<xsd:element name="mongo" type="mongoType">
+					<xsd:annotation>
+						<xsd:documentation><![CDATA[
+Defines a Mongo instance used for accessing MongoDB'.
+							]]></xsd:documentation>
+					</xsd:annotation>
+				</xsd:element>
+			</xsd:sequence>
+			<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>
+						The reference to a Mongo. Will default to 'mongo'.
+					</xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+			<xsd:attribute name="db" 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[
+				</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:complexType>
-  </xsd:element>
+				</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:complexType>
+	</xsd:element>
 
-  <xsd:complexType name="mongo-repository">
-    <xsd:complexContent>
-      <xsd:extension base="repository:repository">
-        <xsd:attributeGroup ref="mongo-repository-attributes" />
-        <xsd:attributeGroup ref="repository:repository-attributes"/>
-      </xsd:extension>
-    </xsd:complexContent>
-  </xsd:complexType>
-  
-  <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="mongo-mapping-context-ref" type="mappingContextRef" default="mappingContext">
-      <xsd:annotation>
-        <xsd:documentation>
-          The reference to a MappingContext. Will pick up a bean named 'mappingContext' by default if available.
-        </xsd:documentation>
-      </xsd:annotation>
-    </xsd:attribute>
-  </xsd:attributeGroup>
+	<xsd:complexType name="mongo-repository">
+		<xsd:complexContent>
+			<xsd:extension base="repository:repository">
+				<xsd:attributeGroup ref="mongo-repository-attributes"/>
+				<xsd:attributeGroup ref="repository:repository-attributes"/>
+			</xsd:extension>
+		</xsd:complexContent>
+	</xsd:complexType>
 
-  <xsd:element name="repositories">
-    <xsd:complexType>
-      <xsd:complexContent>
-        <xsd:extension base="repository:repositories">
-          <xsd:sequence>
-            <xsd:element name="repository" minOccurs="0" maxOccurs="unbounded" type="mongo-repository"/>
-          </xsd:sequence>
-          <xsd:attributeGroup ref="mongo-repository-attributes" />
-          <xsd:attributeGroup ref="repository:repository-attributes"/>
-        </xsd:extension>
-      </xsd:complexContent>
-    </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="mongo-mapping-context-ref" type="mappingContextRef" default="mappingContext">
+			<xsd:annotation>
+				<xsd:documentation>
+					The reference to a MappingContext. Will pick up a bean named 'mappingContext' by default if available.
+				</xsd:documentation>
+			</xsd:annotation>
+		</xsd:attribute>
+	</xsd:attributeGroup>
 
-  <xsd:element name="mapping-converter">
-    <xsd:annotation>
-      <xsd:documentation><![CDATA[
+	<xsd:element name="repositories">
+		<xsd:complexType>
+			<xsd:complexContent>
+				<xsd:extension base="repository:repositories">
+					<xsd:sequence>
+						<xsd:element name="repository" minOccurs="0" maxOccurs="unbounded" type="mongo-repository"/>
+					</xsd:sequence>
+					<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:annotation>
-    <xsd:complexType>
-      <xsd:sequence>
-          <xsd:element name="custom-converters" minOccurs="0">
-            <xsd:annotation>
-              <xsd:documentation><![CDATA[
+		</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:complexType>
-          </xsd:element>
-      </xsd:sequence>
-      <xsd:attribute name="id" type="xsd:ID" use="optional">
-        <xsd:annotation>
-          <xsd:documentation><![CDATA[
+						</xsd:documentation>
+					</xsd:annotation>
+					<xsd:complexType>
+						<xsd:sequence>
+							<xsd:element name="converter" type="customConverterType" minOccurs="0" maxOccurs="unbounded"/>
+						</xsd:sequence>
+					</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[
+				</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="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.document.mongodb.MongoTemplate">
-            The reference to a MongoTemplate. Will default to 'mongoTemplate'.
-          </xsd:documentation>
-        </xsd:annotation>
-      </xsd:attribute>
-    </xsd:complexType>
-  </xsd:element>
+				</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.document.mongodb.MongoTemplate">
+						The reference to a MongoTemplate. Will default to 'mongoTemplate'.
+					</xsd:documentation>
+				</xsd:annotation>
+			</xsd:attribute>
+		</xsd:complexType>
+	</xsd:element>
 
-  <xsd:element name="jmx">
-    <xsd:annotation>
-      <xsd:documentation><![CDATA[
+	<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[
+		</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:annotation>
+			</xsd:attribute>
+		</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="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.document.mongodb.MongoTemplate"/>
-        </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.document.mongodb.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.document.mongodb.MongoFactoryBean"/>
-        </tool:annotation>
-      </xsd:appinfo>
-    </xsd:annotation>
-    <xsd:union memberTypes="xsd:string"/>
-  </xsd:simpleType>
- 
-  
-  <xsd:complexType name="optionsType">
-    <xsd:attribute name="connectionsPerHost" type="xsd:string">
-      <xsd:annotation>
-        <xsd:documentation><![CDATA[
+	<xsd:simpleType name="mongoRef">
+		<xsd:annotation>
+			<xsd:appinfo>
+				<tool:annotation kind="ref">
+					<tool:assignable-to type="org.springframework.data.document.mongodb.MongoFactoryBean"/>
+				</tool:annotation>
+			</xsd:appinfo>
+		</xsd:annotation>
+		<xsd:union memberTypes="xsd:string"/>
+	</xsd:simpleType>
+
+
+	<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:sequence minOccurs="0" maxOccurs="1">
+					<xsd:element name="replica-set" type="replicaSetType">
+						<xsd:annotation>
+							<xsd:documentation><![CDATA[
+	The Mongo Replica set database addresses
+								]]></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="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:complexType>
+
+	<xsd:complexType name="optionsType">
+		<xsd:attribute name="connectionsPerHost" 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="threadsAllowedToBlockForConnectionMultiplier" type="xsd:positiveInteger">
-      <xsd:annotation>
-        <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="threadsAllowedToBlockForConnectionMultiplier" type="xsd:positiveInteger">
+			<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="maxWaitTime" type="xsd:string">
-      <xsd:annotation>
-        <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="maxWaitTime" 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="connectTimeout" type="xsd:string">
-      <xsd:annotation>
-        <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="connectTimeout" 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="socketTimeout" type="xsd:string">
-      <xsd:annotation>
-        <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="socketTimeout" 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="autoConnectRetry" type="xsd:string">
-      <xsd:annotation>
-        <xsd:documentation><![CDATA[
+			</xsd:annotation>
+		</xsd:attribute>
+		<xsd:attribute name="autoConnectRetry" 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:complexType>
+			</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: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[
+	<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: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>
\ No newline at end of file
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/GeoIndexedAppConfig.java b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/GeoIndexedAppConfig.java
index a4ea6fe92..dd3bbbd63 100644
--- a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/GeoIndexedAppConfig.java
+++ b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/GeoIndexedAppConfig.java
@@ -1,11 +1,12 @@
 package org.springframework.data.document.mongodb.mapping;
 
+import com.mongodb.Mongo;
 import org.springframework.context.annotation.Bean;
+import org.springframework.data.document.mongodb.MongoDbFactory;
+import org.springframework.data.document.mongodb.MongoDbFactoryBean;
 import org.springframework.data.document.mongodb.MongoTemplate;
 import org.springframework.data.document.mongodb.config.AbstractMongoConfiguration;
 
-import com.mongodb.Mongo;
-
 public class GeoIndexedAppConfig extends AbstractMongoConfiguration {
 
 	public static String GEO_DB = "geodb";
@@ -16,9 +17,14 @@ public class GeoIndexedAppConfig extends AbstractMongoConfiguration {
 		return new Mongo("localhost");
 	}
 
+	@Bean
+	public MongoDbFactory mongoDbFactory() throws Exception {
+		return new MongoDbFactoryBean(mongo(), GEO_DB);
+	}
+
 	@Bean
 	public MongoTemplate mongoTemplate() throws Exception {
-		return new MongoTemplate(mongo(), "geodb", mappingMongoConverter());
+		return new MongoTemplate(mongoDbFactory(), mappingMongoConverter());
 	}
 
 	public String getMappingBasePackage() {
diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/MongoMappingContextUnitTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/MongoMappingContextUnitTests.java
index 656f91134..dadcdf4db 100644
--- a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/MongoMappingContextUnitTests.java
+++ b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/MongoMappingContextUnitTests.java
@@ -1,3 +1,19 @@
+/*
+ * Copyright (c) 2011 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.
+ * 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.document.mongodb.mapping;
 
 import java.util.Collections;
@@ -7,20 +23,20 @@ import org.junit.Test;
 
 /**
  * Unit tests for {@link MongoMappingContext}.
- * 
+ *
  * @author Oliver Gierke
  */
 public class MongoMappingContextUnitTests {
 
 	@Test
-	public void addsSelfReferencingPersistentEntityCorrectly() {
+	public void addsSelfReferencingPersistentEntityCorrectly() throws Exception {
 		MongoMappingContext context = new MongoMappingContext();
 		context.setInitialEntitySet(Collections.singleton(SampleClass.class));
 		context.afterPropertiesSet();
 	}
-	
+
 	public class SampleClass {
-		
+
 		Map<String, SampleClass> children;
 	}
 }
diff --git a/spring-data-mongodb/src/test/resources/mapping.xml b/spring-data-mongodb/src/test/resources/mapping.xml
index 600d4b404..fbb230cd9 100644
--- a/spring-data-mongodb/src/test/resources/mapping.xml
+++ b/spring-data-mongodb/src/test/resources/mapping.xml
@@ -5,14 +5,8 @@
        xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
        http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd">
 
-  <mongo:mongo host="localhost" port="27017"/>
-
-  <bean id="mongoDbFactory" class="org.springframework.data.document.mongodb.MongoDbFactoryBean">
-  	<constructor-arg name="mongo" ref="mongo"/>
-  	<constructor-arg name="databaseName" value="database"/>
-  </bean>
-  
-  <mongo:mapping-converter base-package="org.springframework.data.document.mongodb.mapping"/>
+  <mongo:db-factory db="database"/>
+  <mongo:mapping-converter id="mappingConverter" base-package="org.springframework.data.document.mongodb.mapping"/>
 
   <bean id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
     <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
diff --git a/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/config/MongoNamespaceTests-context.xml b/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/config/MongoNamespaceTests-context.xml
index bc5e7c4a0..91be74b52 100644
--- a/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/config/MongoNamespaceTests-context.xml
+++ b/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/config/MongoNamespaceTests-context.xml
@@ -1,45 +1,43 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
-	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-	xmlns:mongo="http://www.springframework.org/schema/data/mongo"
-	xmlns:context="http://www.springframework.org/schema/context"
-	xsi:schemaLocation="http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
-		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
-		http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
+			 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+			 xmlns:mongo="http://www.springframework.org/schema/data/mongo"
+			 xmlns:context="http://www.springframework.org/schema/context"
+			 xsi:schemaLocation="http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
+			 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+			 http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-3.0.xsd">
 
-  <context:property-placeholder location="classpath:/org/springframework/data/document/mongodb/config/mongo.properties"/>
+	<context:property-placeholder
+			location="classpath:/org/springframework/data/document/mongodb/config/mongo.properties"/>
 
-  <mongo:mongo host="${mongo.host}" port="${mongo.port}">
-    <mongo:options 
-    	connectionsPerHost="${mongo.connectionsPerHost}"
-    	connectTimeout="${mongo.connectTimeout}"
-    	maxWaitTime="${mongo.maxWaitTime}" 
-    	autoConnectRetry="${mongo.autoConnectRetry}"/>
-  </mongo:mongo>
+	<mongo:db-factory db="database">
+		<mongo:mongo host="${mongo.host}" port="${mongo.port}">
+			<mongo:options
+					connectionsPerHost="${mongo.connectionsPerHost}"
+					connectTimeout="${mongo.connectTimeout}"
+					maxWaitTime="${mongo.maxWaitTime}"
+					autoConnectRetry="${mongo.autoConnectRetry}"/>
+		</mongo:mongo>
+	</mongo:db-factory>
 
-  <mongo:mongo id="defaultMongo" host="localhost" port="27017"/>
+	<mongo:mongo id="defaultMongo" host="localhost" port="27017"/>
 
-  <mongo:mongo id="noAttrMongo"/>
+	<mongo:mongo id="noAttrMongo"/>
 
-  <mongo:mapping-converter>
-    <mongo:custom-converters>
-      <mongo:converter ref="readConverter"/>
-      <mongo:converter>
-        <bean class="org.springframework.data.document.mongodb.PersonWriteConverter"/>
-      </mongo:converter>
-    </mongo:custom-converters>
-  </mongo:mapping-converter>
-    
-  <bean id="readConverter" class="org.springframework.data.document.mongodb.PersonReadConverter"/>
+	<mongo:mapping-converter>
+		<mongo:custom-converters>
+			<mongo:converter ref="readConverter"/>
+			<mongo:converter>
+				<bean class="org.springframework.data.document.mongodb.PersonWriteConverter"/>
+			</mongo:converter>
+		</mongo:custom-converters>
+	</mongo:mapping-converter>
 
-  <bean id="mongoDbFactory" class="org.springframework.data.document.mongodb.MongoDbFactoryBean">
-  	<constructor-arg name="mongo" ref="mongo"/>
-  	<constructor-arg name="databaseName" value="database"/>
-  </bean>
+	<bean id="readConverter" class="org.springframework.data.document.mongodb.PersonReadConverter"/>
 
-  <bean id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
-    <constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
-    <constructor-arg name="mongoConverter" ref="mappingConverter"/>
-  </bean>
+	<bean id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
+		<constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
+		<constructor-arg name="mongoConverter" ref="mappingConverter"/>
+	</bean>
 
 </beans>
diff --git a/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/repository/PersonRepositoryIntegrationTests-context.xml b/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/repository/PersonRepositoryIntegrationTests-context.xml
index 8cd6df099..db602c671 100644
--- a/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/repository/PersonRepositoryIntegrationTests-context.xml
+++ b/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/repository/PersonRepositoryIntegrationTests-context.xml
@@ -1,38 +1,22 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd">
+			 xmlns:mongo="http://www.springframework.org/schema/data/mongo"
+			 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+			 xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+       http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd">
 
-  <bean id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
-    <constructor-arg>
-      <bean id="mongoDbFactory" class="org.springframework.data.document.mongodb.MongoDbFactoryBean">
-        <constructor-arg name="mongo">
-          <bean id="mongo" class="org.springframework.data.document.mongodb.MongoFactoryBean">
-            <property name="host" value="localhost"/>
-            <property name="port" value="27017"/>
-          </bean>
-	  	</constructor-arg>
-	  	<constructor-arg name="databaseName" value="repositories"/>
-	  </bean>
-    </constructor-arg>
-	<constructor-arg>
-	  <bean id="mongoConverter" class="org.springframework.data.document.mongodb.convert.MappingMongoConverter">
-	  	<constructor-arg ref="mappingContext" />
-	  </bean>
-	</constructor-arg>
-  </bean>
-  
-  <bean id="mappingContext" class="org.springframework.data.document.mongodb.mapping.MongoMappingContext" />
+	<mongo:db-factory db="repositories"/>
+	<mongo:mapping-converter base-package="org.springframework.data.document.mongodb.repository"/>
 
-  <bean class="org.springframework.data.document.mongodb.mapping.MongoPersistentEntityIndexCreator">
-  	<constructor-arg ref="mappingContext" />
-  	<constructor-arg ref="mongoTemplate" />
-  </bean>
-  
-  <bean class="org.springframework.data.document.mongodb.repository.MongoRepositoryFactoryBean">
-    <property name="template" ref="mongoTemplate"/>
-    <property name="mappingContext" ref="mappingContext" />
-    <property name="repositoryInterface" value="org.springframework.data.document.mongodb.repository.PersonRepository"/>
-  </bean>
+	<bean id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
+		<constructor-arg ref="mongoDbFactory"/>
+		<constructor-arg ref="mappingConverter"/>
+	</bean>
+
+	<bean class="org.springframework.data.document.mongodb.repository.MongoRepositoryFactoryBean">
+		<property name="template" ref="mongoTemplate"/>
+		<property name="mappingContext" ref="mappingContext"/>
+		<property name="repositoryInterface" value="org.springframework.data.document.mongodb.repository.PersonRepository"/>
+	</bean>
 
 </beans>
diff --git a/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/repository/config/MongoNamespaceIntegrationTests-context.xml b/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/repository/config/MongoNamespaceIntegrationTests-context.xml
index acf4c1d3b..b9757262f 100644
--- a/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/repository/config/MongoNamespaceIntegrationTests-context.xml
+++ b/spring-data-mongodb/src/test/resources/org/springframework/data/document/mongodb/repository/config/MongoNamespaceIntegrationTests-context.xml
@@ -1,28 +1,23 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <beans xmlns="http://www.springframework.org/schema/beans"
-       xmlns:mongo="http://www.springframework.org/schema/data/mongo"
-       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-       xmlns:repository="http://www.springframework.org/schema/data/repository"
-       xsi:schemaLocation="http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
-		http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
-		http://www.springframework.org/schema/data/repository http://www.springframework.org/schema/data/repository/spring-repository-1.0.xsd">
-  
-  <mongo:mongo id="mongo" />
+			 xmlns:mongo="http://www.springframework.org/schema/data/mongo"
+			 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+			 xmlns:repository="http://www.springframework.org/schema/data/repository"
+			 xsi:schemaLocation="http://www.springframework.org/schema/data/mongo http://www.springframework.org/schema/data/mongo/spring-mongo-1.0.xsd
+			 http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
+			 http://www.springframework.org/schema/data/repository http://www.springframework.org/schema/data/repository/spring-repository-1.0.xsd">
 
-  <bean id="mongoDbFactory" class="org.springframework.data.document.mongodb.MongoDbFactoryBean">
-  	<constructor-arg name="mongo" ref="mongo"/>
-  	<constructor-arg name="databaseName" value="repositories"/>
-  </bean>
-  
-  <bean id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
-    <constructor-arg name="mongoDbFactory" ref="mongoDbFactory" />
-    <constructor-arg name="mongoConverter">
-      <mongo:mapping-converter />
-    </constructor-arg>
-  </bean>
+	<mongo:db-factory db="repositories"/>
 
-  <mongo:repositories base-package="org.springframework.data.**.repository">
-    <repository:exclude-filter type="regex" expression=".*MongoRepository"/>
-  </mongo:repositories>
+	<bean id="mongoTemplate" class="org.springframework.data.document.mongodb.MongoTemplate">
+		<constructor-arg name="mongoDbFactory" ref="mongoDbFactory"/>
+		<constructor-arg name="mongoConverter">
+			<mongo:mapping-converter/>
+		</constructor-arg>
+	</bean>
+
+	<mongo:repositories base-package="org.springframework.data.**.repository">
+		<repository:exclude-filter type="regex" expression=".*MongoRepository"/>
+	</mongo:repositories>
 
 </beans>
diff --git a/spring-data-mongodb/src/test/resources/template-mapping.xml b/spring-data-mongodb/src/test/resources/template-mapping.xml
index 8441112c3..a9c1ff2ae 100644
--- a/spring-data-mongodb/src/test/resources/template-mapping.xml
+++ b/spring-data-mongodb/src/test/resources/template-mapping.xml
@@ -7,7 +7,7 @@
 
   <bean class="org.springframework.data.document.mongodb.TestMongoConfiguration"/>
   
-  <mongo:mongo host="localhost" port="27017"/>
+  <mongo:db-factory/>
 
   <bean id="mongoDbFactory" class="org.springframework.data.document.mongodb.MongoDbFactoryBean">
   	<constructor-arg name="mongo" ref="mongo"/>