From 07188d2a279daab5b6e5ca38b6a23f24547d523e Mon Sep 17 00:00:00 2001 From: Jon Brisbin Date: Fri, 18 Mar 2011 09:56:18 -0500 Subject: [PATCH] Fixed namespace handler support, added a MappingContextEvent listener for (asynchronously) creating indexes whenever entities are registered with the mapper. Removed that part of the code from the MongoMappingConfigurationBuilder, which means it no longer has that dependency on MongoTemplate. Also tweaked some afterPropertiesSet methods to try and reduce the problem of chicken-and-egg dependencies within mapping components. --- .../data/document/mongodb/MongoTemplate.java | 3 - .../config/MongoMappingConverterParser.java | 62 +++++- .../convert/MappingMongoConverter.java | 7 +- .../MongoMappingConfigurationBuilder.java | 121 +---------- .../mapping/event/IndexCreationListener.java | 201 ++++++++++++++++++ .../mongodb/config/spring-mongo-1.0.xsd | 43 ++++ .../mongodb/mapping/GenericMappingTests.java | 10 +- .../src/test/resources/log4j.properties | 1 + 8 files changed, 310 insertions(+), 138 deletions(-) create mode 100644 spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/event/IndexCreationListener.java 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 3672575bb..c56c0dfc6 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 @@ -57,7 +57,6 @@ import org.springframework.data.document.mongodb.convert.SimpleMongoConverter; import org.springframework.data.document.mongodb.event.CollectionCreatedEvent; import org.springframework.data.document.mongodb.event.InsertEvent; import org.springframework.data.document.mongodb.event.SaveEvent; -import org.springframework.data.document.mongodb.mapping.MongoMappingConfigurationBuilder; import org.springframework.data.document.mongodb.query.IndexDefinition; import org.springframework.data.document.mongodb.query.Query; import org.springframework.data.document.mongodb.query.Update; @@ -1062,8 +1061,6 @@ public class MongoTemplate implements InitializingBean, MongoOperations, Applica private void initializeMappingMongoConverter(MappingMongoConverter converter) { converter.setMongo(mongo); converter.setDefaultDatabase(databaseName); - ((MongoMappingConfigurationBuilder) converter.getMappingContext().getMappingConfigurationBuilder()) - .setMongoTemplate(this); } /* diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoMappingConverterParser.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoMappingConverterParser.java index 35863a8ef..1a96a0276 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoMappingConverterParser.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/config/MongoMappingConverterParser.java @@ -20,16 +20,23 @@ import java.util.HashSet; import java.util.Set; 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.RuntimeBeanReference; import org.springframework.beans.factory.support.AbstractBeanDefinition; import org.springframework.beans.factory.support.BeanDefinitionBuilder; -import org.springframework.beans.factory.xml.AbstractSingleBeanDefinitionParser; +import org.springframework.beans.factory.support.BeanDefinitionRegistry; +import org.springframework.beans.factory.support.GenericBeanDefinition; +import org.springframework.beans.factory.xml.AbstractBeanDefinitionParser; import org.springframework.beans.factory.xml.ParserContext; import org.springframework.context.annotation.ClassPathScanningCandidateComponentProvider; import org.springframework.core.type.filter.AnnotationTypeFilter; import org.springframework.data.annotation.Persistent; import org.springframework.data.document.mongodb.convert.MappingMongoConverter; import org.springframework.data.document.mongodb.mapping.Document; +import org.springframework.data.document.mongodb.mapping.MongoMappingConfigurationBuilder; +import org.springframework.data.document.mongodb.mapping.event.IndexCreationListener; +import org.springframework.data.mapping.BasicMappingContext; import org.springframework.data.mapping.model.MappingException; import org.w3c.dom.Element; @@ -40,8 +47,12 @@ import org.w3c.dom.Element; * Time: 9:26 AM * To change this template use File | Settings | File Templates. */ -public class MongoMappingConverterParser extends AbstractSingleBeanDefinitionParser { +public class MongoMappingConverterParser extends AbstractBeanDefinitionParser { + private static final String CONFIGURATION_BUILDER = "mappingConfigurationBuilder"; + private static final String MAPPING_CONTEXT = "mappingContext"; + private static final String INDEX_CREATION_LISTENER = "indexCreationListener"; + private static final String TEMPLATE = "mongoTemplate"; private static final String BASE_PACKAGE = "base-package"; @Override @@ -50,15 +61,31 @@ public class MongoMappingConverterParser extends AbstractSingleBeanDefinitionPar } @Override - protected Class getBeanClass(Element element) { - return MappingMongoConverter.class; - } + protected AbstractBeanDefinition parseInternal(Element element, ParserContext parserContext) { + BeanDefinitionRegistry registry = parserContext.getRegistry(); + + String builderRef = element.getAttribute("mapping-config-builder-ref"); + if (null == builderRef || "".equals(builderRef)) { + GenericBeanDefinition builder = new GenericBeanDefinition(); + builder.setBeanClass(MongoMappingConfigurationBuilder.class); + registry.registerBeanDefinition(CONFIGURATION_BUILDER, builder); + builderRef = CONFIGURATION_BUILDER; + } + + String ctxRef = element.getAttribute("mapping-context-ref"); + if (null == ctxRef || "".equals(ctxRef)) { + BeanDefinitionBuilder mappingContextBuilder = BeanDefinitionBuilder.genericBeanDefinition(BasicMappingContext.class); + mappingContextBuilder.addPropertyReference("mappingConfigurationBuilder", builderRef); + registry.registerBeanDefinition(MAPPING_CONTEXT, mappingContextBuilder.getBeanDefinition()); + ctxRef = MAPPING_CONTEXT; + } + + BeanDefinitionBuilder converterBuilder = BeanDefinitionBuilder.genericBeanDefinition(MappingMongoConverter.class); + converterBuilder.addPropertyReference("mappingContext", ctxRef); - @Override - protected void doParse(Element element, ParserContext parserContext, BeanDefinitionBuilder builder) { String autowire = element.getAttribute("autowire"); if (null != autowire || !"".equals(autowire)) { - builder.addPropertyValue("autowirePersistentBeans", Boolean.parseBoolean(autowire)); + converterBuilder.addPropertyValue("autowirePersistentBeans", Boolean.parseBoolean(autowire)); } // Need a reference to a MongoTemplate @@ -66,7 +93,20 @@ public class MongoMappingConverterParser extends AbstractSingleBeanDefinitionPar if (null == mongoRef || "".equals(mongoRef)) { mongoRef = "mongo"; } - builder.addPropertyReference("mongo", mongoRef); + converterBuilder.addPropertyReference("mongo", mongoRef); + + try { + registry.getBeanDefinition(INDEX_CREATION_LISTENER); + } catch (NoSuchBeanDefinitionException ignored) { + String templateRef = element.getAttribute("mongo-template-ref"); + if (null == templateRef || "".equals(templateRef)) { + templateRef = TEMPLATE; + } + BeanDefinitionBuilder indexListenerBuilder = BeanDefinitionBuilder.genericBeanDefinition(IndexCreationListener.class); + indexListenerBuilder.addPropertyValue("mongoTemplate", new RuntimeBeanReference(templateRef)); + indexListenerBuilder.setDestroyMethodName("cleanUp"); + registry.registerBeanDefinition(INDEX_CREATION_LISTENER, indexListenerBuilder.getBeanDefinition()); + } // Scan for @Document entities String basePackage = element.getAttribute(BASE_PACKAGE); @@ -85,9 +125,11 @@ public class MongoMappingConverterParser extends AbstractSingleBeanDefinitionPar throw new MappingException(e.getMessage(), e); } } - builder.addPropertyValue("initialEntitySet", initialEntitySet); + converterBuilder.addPropertyValue("initialEntitySet", initialEntitySet); } } + + return converterBuilder.getBeanDefinition(); } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/convert/MappingMongoConverter.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/convert/MappingMongoConverter.java index bc74d2c88..42853cc53 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/convert/MappingMongoConverter.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/convert/MappingMongoConverter.java @@ -50,9 +50,7 @@ import org.springframework.core.convert.ConversionService; import org.springframework.core.convert.converter.Converter; import org.springframework.core.convert.support.ConversionServiceFactory; import org.springframework.core.convert.support.GenericConversionService; -import org.springframework.data.document.mongodb.mapping.MongoMappingConfigurationBuilder; import org.springframework.data.mapping.AssociationHandler; -import org.springframework.data.mapping.BasicMappingContext; import org.springframework.data.mapping.MappingBeanHelper; import org.springframework.data.mapping.PropertyHandler; import org.springframework.data.mapping.model.Association; @@ -82,7 +80,7 @@ public class MappingMongoConverter implements MongoConverter, ApplicationContext protected final GenericConversionService conversionService = ConversionServiceFactory.createDefaultConversionService(); protected final Map, Class> customTypeMapping = new HashMap, Class>(); protected SpelExpressionParser spelExpressionParser = new SpelExpressionParser(); - protected MappingContext mappingContext = new BasicMappingContext(new MongoMappingConfigurationBuilder()); + protected MappingContext mappingContext; protected ApplicationContext applicationContext; protected boolean autowirePersistentBeans = false; protected boolean useFieldAccessOnly = true; @@ -271,7 +269,6 @@ public class MappingMongoConverter implements MongoConverter, ApplicationContext // Set properties not already set in the constructor entity.doWithProperties(new PropertyHandler() { public void doWithPersistentProperty(PersistentProperty prop) { - if (ctorParamNames.contains(prop.getName())) { return; } @@ -620,7 +617,7 @@ public class MappingMongoConverter implements MongoConverter, ApplicationContext public void afterPropertiesSet() throws Exception { for (Class entity : initialEntitySet) { - //mappingContext.addPersistentEntity(entity); + mappingContext.addPersistentEntity(entity); } } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/MongoMappingConfigurationBuilder.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/MongoMappingConfigurationBuilder.java index 5f956e21c..c75f4794c 100644 --- a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/MongoMappingConfigurationBuilder.java +++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/MongoMappingConfigurationBuilder.java @@ -18,27 +18,12 @@ package org.springframework.data.document.mongodb.mapping; import java.beans.PropertyDescriptor; import java.lang.reflect.Field; -import java.util.HashMap; -import java.util.Map; import java.util.Set; -import com.mongodb.BasicDBObject; -import com.mongodb.DBCollection; -import com.mongodb.DBObject; -import com.mongodb.MongoException; -import com.mongodb.util.JSON; import org.bson.types.CodeWScope; import org.bson.types.ObjectId; -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.index.CompoundIndex; -import org.springframework.data.document.mongodb.index.CompoundIndexes; -import org.springframework.data.document.mongodb.index.IndexDirection; -import org.springframework.data.document.mongodb.index.Indexed; import org.springframework.data.mapping.BasicMappingConfigurationBuilder; import org.springframework.data.mapping.MappingBeanHelper; -import org.springframework.data.mapping.model.Association; import org.springframework.data.mapping.model.MappingConfigurationException; import org.springframework.data.mapping.model.MappingContext; import org.springframework.data.mapping.model.PersistentEntity; @@ -50,15 +35,7 @@ import org.springframework.data.util.TypeInformation; */ public class MongoMappingConfigurationBuilder extends BasicMappingConfigurationBuilder { - protected Map compoundIndexes = new HashMap(); - protected Map fieldIndexes = new HashMap(); - protected MongoTemplate mongoTemplate; - public MongoMappingConfigurationBuilder() { - } - - public MongoMappingConfigurationBuilder(MongoTemplate mongoTemplate) { - this.mongoTemplate = mongoTemplate; augmentSimpleTypes(); } @@ -70,63 +47,17 @@ public class MongoMappingConfigurationBuilder extends BasicMappingConfigurationB simpleTypes.add(CodeWScope.class); } - public MongoTemplate getMongoTemplate() { - return mongoTemplate; - } - - public void setMongoTemplate(MongoTemplate mongoTemplate) { - this.mongoTemplate = mongoTemplate; - } - @Override - public PersistentProperty createPersistentProperty(Field field, PropertyDescriptor descriptor, TypeInformation information) throws MappingConfigurationException { - PersistentProperty property = new MongoPersistentProperty(field, descriptor, information); - if (field.isAnnotationPresent(Indexed.class)) { - Indexed index = field.getAnnotation(Indexed.class); - String collection = index.collection(); - if ("".equals(collection)) { - collection = field.getName(); - } - if (!fieldIndexes.containsKey(collection)) { - ensureIndex(collection, index.name(), null, index.direction(), index.unique(), index.dropDups(), index.sparse()); - fieldIndexes.put(collection, index); - } - } - return property; + public PersistentProperty createPersistentProperty(Field field, + PropertyDescriptor descriptor, + TypeInformation information) throws MappingConfigurationException { + return new MongoPersistentProperty(field, descriptor, information); } @Override - public PersistentEntity createPersistentEntity(TypeInformation typeInformation, MappingContext mappingContext) throws MappingConfigurationException { - - MongoPersistentEntity entity = new MongoPersistentEntity(mappingContext, typeInformation); - Class type = typeInformation.getType(); - - // Check for special collection setting - if (type.isAnnotationPresent(Document.class)) { - Document doc = type.getAnnotation(Document.class); - String collection = doc.collection(); - if ("".equals(collection)) { - collection = type.getSimpleName().toLowerCase(); - } - entity.setCollection(collection); - } - - // Make sure indexes get created - if (type.isAnnotationPresent(CompoundIndexes.class)) { - CompoundIndexes indexes = type.getAnnotation(CompoundIndexes.class); - for (CompoundIndex index : indexes.value()) { - String indexColl = index.collection(); - if ("".equals(indexColl)) { - indexColl = type.getSimpleName().toLowerCase(); - } - if (!compoundIndexes.containsKey(indexColl)) { - ensureIndex(indexColl, index.name(), index.def(), index.direction(), index.unique(), index.dropDups(), index.sparse()); - compoundIndexes.put(indexColl, index); - } - } - } - - return entity; + public PersistentEntity createPersistentEntity(TypeInformation typeInformation, + MappingContext mappingContext) throws MappingConfigurationException { + return new MongoPersistentEntity(mappingContext, typeInformation); } @Override @@ -137,42 +68,4 @@ public class MongoMappingConfigurationBuilder extends BasicMappingConfigurationB return super.isAssociation(field, descriptor); } - @Override - public Association createAssociation(PersistentProperty property) { - return super.createAssociation(property); - } - - protected void ensureIndex(String collection, - final String name, - final String def, - final IndexDirection direction, - final boolean unique, - final boolean dropDups, - final boolean sparse) { - if (null != mongoTemplate) { - mongoTemplate.execute(collection, new CollectionCallback() { - 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(); - if (!"".equals(name)) { - opts.put("name", name); - } - opts.put("dropDups", dropDups); - opts.put("sparse", sparse); - opts.put("unique", unique); - collection.ensureIndex(defObj, opts); - return null; - } - }); - } else { - log.error("MongoTemplate was NULL! Not creating index: " + def + " on collection: " + collection); - } - } - } diff --git a/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/event/IndexCreationListener.java b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/event/IndexCreationListener.java new file mode 100644 index 000000000..d21ecbf3c --- /dev/null +++ b/spring-data-mongodb/src/main/java/org/springframework/data/document/mongodb/mapping/event/IndexCreationListener.java @@ -0,0 +1,201 @@ +/* + * 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 java.lang.reflect.Field; +import java.util.Collections; +import java.util.HashMap; +import java.util.Map; +import java.util.Set; +import java.util.concurrent.ConcurrentHashMap; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.LinkedBlockingQueue; + +import com.mongodb.BasicDBObject; +import com.mongodb.DBCollection; +import com.mongodb.DBObject; +import com.mongodb.MongoException; +import com.mongodb.util.JSON; +import org.slf4j.Logger; +import org.slf4j.LoggerFactory; +import org.springframework.beans.BeansException; +import org.springframework.context.ApplicationContext; +import org.springframework.context.ApplicationContextAware; +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.index.CompoundIndex; +import org.springframework.data.document.mongodb.index.CompoundIndexes; +import org.springframework.data.document.mongodb.index.IndexDirection; +import org.springframework.data.document.mongodb.index.Indexed; +import org.springframework.data.document.mongodb.mapping.Document; +import org.springframework.data.document.mongodb.mapping.MongoPersistentEntity; +import org.springframework.data.mapping.PropertyHandler; +import org.springframework.data.mapping.event.MappingContextEvent; +import org.springframework.data.mapping.model.PersistentProperty; + +/** + * @author Jon Brisbin + */ +public class IndexCreationListener implements ApplicationListener, ApplicationContextAware { + + private static final Logger log = LoggerFactory.getLogger(IndexCreationListener.class); + + private Map compoundIndexes = new HashMap(); + private Map fieldIndexes = new HashMap(); + private ApplicationContext applicationContext; + private MongoTemplate mongoTemplate; + private ExecutorService worker = Executors.newFixedThreadPool(1); + private LinkedBlockingQueue mappingEvents = new LinkedBlockingQueue(); + private Set> classesSeen = Collections.newSetFromMap(new ConcurrentHashMap, Boolean>()); + + public IndexCreationListener() { + worker.submit(new IndexCreationWorker()); + } + + public void setApplicationContext(ApplicationContext applicationContext) throws BeansException { + this.applicationContext = applicationContext; + } + + public MongoTemplate getMongoTemplate() { + return mongoTemplate; + } + + public void setMongoTemplate(MongoTemplate mongoTemplate) { + this.mongoTemplate = mongoTemplate; + } + + public void onApplicationEvent(MappingContextEvent event) { + mappingEvents.add(event); + } + + public void cleanUp() throws InterruptedException { + while (mappingEvents.size() > 0) { + Thread.yield(); + } + } + + private class IndexCreationWorker implements Runnable { + public void run() { + while (true) { + MappingContextEvent event = null; + try { + event = mappingEvents.take(); + if (null == applicationContext) { + Thread.sleep(500); + mappingEvents.add(event); + } + } catch (InterruptedException ignored) { + if (log.isDebugEnabled()) { + log.debug(ignored.getMessage(), ignored); + } + break; + } + if (event.getPersistentEntity() instanceof MongoPersistentEntity) { + MongoPersistentEntity entity = (MongoPersistentEntity) event.getPersistentEntity(); + Class type = event.getTypeInformation().getType(); + if (!classesSeen.contains(type)) { + if (log.isDebugEnabled()) { + log.debug("Analyzing class " + type + " for index information."); + } + // Check for special collection setting + if (type.isAnnotationPresent(Document.class)) { + Document doc = type.getAnnotation(Document.class); + String collection = doc.collection(); + if ("".equals(collection)) { + collection = type.getSimpleName().toLowerCase(); + } + entity.setCollection(collection); + } + + // Make sure indexes get created + if (type.isAnnotationPresent(CompoundIndexes.class)) { + CompoundIndexes indexes = type.getAnnotation(CompoundIndexes.class); + for (CompoundIndex index : indexes.value()) { + String indexColl = index.collection(); + if ("".equals(indexColl)) { + indexColl = type.getSimpleName().toLowerCase(); + } + if (!compoundIndexes.containsKey(indexColl)) { + ensureIndex(indexColl, index.name(), index.def(), index.direction(), index.unique(), index.dropDups(), index.sparse()); + if (log.isDebugEnabled()) { + log.debug("Created compound index " + index); + } + compoundIndexes.put(indexColl, index); + } + } + } + + entity.doWithProperties(new PropertyHandler() { + public void doWithPersistentProperty(PersistentProperty persistentProperty) { + Field field = persistentProperty.getField(); + if (field.isAnnotationPresent(Indexed.class)) { + Indexed index = field.getAnnotation(Indexed.class); + String collection = index.collection(); + if ("".equals(collection)) { + collection = field.getName(); + } + if (!fieldIndexes.containsKey(collection)) { + ensureIndex(collection, index.name(), null, index.direction(), index.unique(), index.dropDups(), index.sparse()); + if (log.isDebugEnabled()) { + log.debug("Created property index " + index); + } + fieldIndexes.put(collection, index); + } + } + } + }); + + classesSeen.add(type); + } + } + } + } + + 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() { + 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(); + if (!"".equals(name)) { + opts.put("name", name); + } + opts.put("dropDups", dropDups); + opts.put("sparse", sparse); + opts.put("unique", unique); + collection.ensureIndex(defObj, opts); + return null; + } + }); + } + } + +} 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 e46cbdef6..8ca4483de 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 @@ -127,6 +127,27 @@ This controls whether or not to run entities through the BeanFactory's autowirin + + + + The reference to a MappingConfigurationBuilder. Will default to 'mappingConfigBuilder'. + + + + + + + The reference to a MappingContext. Will default to 'mappingContext'. + + + + + + + The reference to a MongoTemplate. Will default to 'mongoTemplate'. + + + @@ -146,6 +167,28 @@ The name of the Mongo object that determines what server to monitor. (by default + + + + + + + + + + + + + + + + + + + + + + diff --git a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/GenericMappingTests.java b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/GenericMappingTests.java index 539aabcac..2a6a20939 100644 --- a/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/GenericMappingTests.java +++ b/spring-data-mongodb/src/test/java/org/springframework/data/document/mongodb/mapping/GenericMappingTests.java @@ -16,10 +16,8 @@ package org.springframework.data.document.mongodb.mapping; -import static org.hamcrest.CoreMatchers.is; -import static org.hamcrest.CoreMatchers.notNullValue; -import static org.junit.Assert.assertThat; -import static org.junit.Assert.assertTrue; +import static org.hamcrest.CoreMatchers.*; +import static org.junit.Assert.*; import com.mongodb.BasicDBObject; import com.mongodb.DBObject; @@ -43,13 +41,13 @@ public class GenericMappingTests { BasicMappingContext context; MongoConverter converter; - + @Mock ApplicationContext applicationContext; @Before public void setUp() { - context = new BasicMappingContext(new MongoMappingConfigurationBuilder(null)); + context = new BasicMappingContext(new MongoMappingConfigurationBuilder()); context.setApplicationContext(applicationContext); context.addPersistentEntity(StringWrapper.class); converter = new MappingMongoConverter(context); diff --git a/spring-data-mongodb/src/test/resources/log4j.properties b/spring-data-mongodb/src/test/resources/log4j.properties index 6d5422d74..0bf8e3c31 100644 --- a/spring-data-mongodb/src/test/resources/log4j.properties +++ b/spring-data-mongodb/src/test/resources/log4j.properties @@ -6,6 +6,7 @@ log4j.appender.stdout.layout.ConversionPattern=%d %p [%c] - <%m>%n log4j.category.org.apache.activemq=ERROR log4j.category.org.springframework.batch=DEBUG +log4j.category.org.springframework.data.document.mongodb.mapping=DEBUG log4j.category.org.springframework.transaction=INFO log4j.category.org.hibernate.SQL=DEBUG