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