Java MongoMappingContext类代码示例

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@Bean
public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory,
		MongoMappingContext context, BeanFactory beanFactory) {
	DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
	MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver,
			context);

	// remove _class field
	mappingConverter.setTypeMapper(new DefaultMongoTypeMapper(null));

	try {
		mappingConverter
				.setCustomConversions(beanFactory.getBean(CustomConversions.class));
	}
	catch (NoSuchBeanDefinitionException ex) {
		// Ignore
	}
	return mappingConverter;
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean(MongoConverter.class)
public MappingMongoConverter mappingMongoConverter(MongoDbFactory factory,
		MongoMappingContext context, BeanFactory beanFactory) {
	DbRefResolver dbRefResolver = new DefaultDbRefResolver(factory);
	MappingMongoConverter mappingConverter = new MappingMongoConverter(dbRefResolver,
			context);
	try {
		mappingConverter
				.setCustomConversions(beanFactory.getBean(CustomConversions.class));
	}
	catch (NoSuchBeanDefinitionException ex) {
		// Ignore
	}
	return mappingConverter;
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
public void testFieldNamingStrategy(String strategy,
		Class<? extends FieldNamingStrategy> expectedType) {
	this.context = new AnnotationConfigApplicationContext();
	if (strategy != null) {
		EnvironmentTestUtils.addEnvironment(this.context,
				"spring.data.mongodb.field-naming-strategy:" + strategy);
	}
	this.context.register(PropertyPlaceholderAutoConfiguration.class,
			MongoAutoConfiguration.class, MongoDataAutoConfiguration.class);
	this.context.refresh();
	MongoMappingContext mappingContext = this.context
			.getBean(MongoMappingContext.class);
	FieldNamingStrategy fieldNamingStrategy = (FieldNamingStrategy) ReflectionTestUtils
			.getField(mappingContext, "fieldNamingStrategy");
	assertThat(fieldNamingStrategy.getClass()).isEqualTo(expectedType);
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
public void testFieldNamingStrategy(String strategy,
		Class<? extends FieldNamingStrategy> expectedType) {
	this.context = new AnnotationConfigApplicationContext();
	if (strategy != null) {
		EnvironmentTestUtils.addEnvironment(this.context,
				"spring.data.mongodb.field-naming-strategy:" + strategy);
	}
	this.context.register(PropertyPlaceholderAutoConfiguration.class,
			MongoAutoConfiguration.class, MongoDataAutoConfiguration.class);
	this.context.refresh();
	MongoMappingContext mappingContext = this.context
			.getBean(MongoMappingContext.class);
	FieldNamingStrategy fieldNamingStrategy = (FieldNamingStrategy) ReflectionTestUtils
			.getField(mappingContext, "fieldNamingStrategy");
	assertEquals(expectedType, fieldNamingStrategy.getClass());
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
protected void createIndecesFor(final Class<?> type) {
	final MongoMappingContext mappingContext =
			(MongoMappingContext) getMongoTemplate().getConverter().getMappingContext();
	final MongoPersistentEntityIndexResolver indexResolver =
			new MongoPersistentEntityIndexResolver(mappingContext);
	for (final IndexDefinitionHolder indexToCreate : indexResolver.resolveIndexForClass(type)) {
		createIndex(indexToCreate);
	}
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@Primary
@Bean(name = "naiveMongoTemplate")
public MongoTemplate naiveMongoTemplate() throws Exception {
    MappingMongoConverter converter =
            new MappingMongoConverter(new DefaultDbRefResolver(naiveFactory()), new MongoMappingContext());
    converter.setTypeMapper(new DefaultMongoTypeMapper(null));
    return new MongoTemplate(naiveFactory(), converter);
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@Bean
@Qualifier("completeMongoTemplate")
public MongoTemplate completeMongoTemplate() throws Exception {
    MappingMongoConverter converter =
            new MappingMongoConverter(new DefaultDbRefResolver(completeFactory()), new MongoMappingContext());
    converter.setTypeMapper(new DefaultMongoTypeMapper(null));
    return new MongoTemplate(completeFactory(), converter);
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
public MongoContainer(MongoClient mongoClient,
					  MongoTemplate template,
					  MongoDbFactory mongoDbFactory,
					  MongoMappingContext context,
					  Environment environment) {
	this.mongoClient = mongoClient;
	this.template = template;
	this.mongoDbFactory = mongoDbFactory;
	this.context = context;
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
/**
 * Create the Mongo container (used by scripts to access MongoDB)
 * @param mongoClient - the MongoClient (from Spring)
 * @param environment - the environment
 * @return the MongoContainer
 */
@Bean
public MongoContainer mongoContainer(MongoClient mongoClient,
									  MongoTemplate template,
									  MongoDbFactory mongoDbFactory,
									  MongoMappingContext context,
									  Environment environment) {
	return new MongoContainer(mongoClient, template, mongoDbFactory, context, environment);
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
private void initMongoMappingContext(String[] domainPackage) {
    BeanDefinitionBuilder mappingContextBuilder = BeanDefinitionBuilder.genericBeanDefinition(MongoMappingContext.class);
    Set<String> classesToAdd = getInititalEntityClasses(domainPackage);
    if (classesToAdd != null) {
        mappingContextBuilder.addPropertyValue("initialEntitySet", classesToAdd);
    }

    BEAN_DEFINITION_MAP.put(MONGO_MAPPING_CONTEXT_BEAN_NAME, mappingContextBuilder.getBeanDefinition());
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public MongoMappingContext mongoMappingContext(BeanFactory beanFactory)
		throws ClassNotFoundException {
	MongoMappingContext context = new MongoMappingContext();
	context.setInitialEntitySet(new EntityScanner(this.applicationContext)
			.scan(Document.class, Persistent.class));
	Class<?> strategyClass = this.properties.getFieldNamingStrategy();
	if (strategyClass != null) {
		context.setFieldNamingStrategy(
				(FieldNamingStrategy) BeanUtils.instantiate(strategyClass));
	}
	return context;
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@Test
public void usesAutoConfigurationPackageToPickUpDocumentTypes() {
	this.context = new AnnotationConfigApplicationContext();
	String cityPackage = City.class.getPackage().getName();
	AutoConfigurationPackages.register(this.context, cityPackage);
	this.context.register(MongoAutoConfiguration.class,
			MongoDataAutoConfiguration.class);
	this.context.refresh();
	assertDomainTypesDiscovered(this.context.getBean(MongoMappingContext.class),
			City.class);
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@Test
@SuppressWarnings("unchecked")
public void entityScanShouldSetInitialEntitySet() throws Exception {
	this.context = new AnnotationConfigApplicationContext();
	this.context.register(EntityScanConfig.class,
			PropertyPlaceholderAutoConfiguration.class, MongoAutoConfiguration.class,
			MongoDataAutoConfiguration.class);
	this.context.refresh();
	MongoMappingContext mappingContext = this.context
			.getBean(MongoMappingContext.class);
	Set<Class<?>> initialEntitySet = (Set<Class<?>>) ReflectionTestUtils
			.getField(mappingContext, "initialEntitySet");
	assertThat(initialEntitySet).containsOnly(City.class, Country.class);
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@SuppressWarnings({ "unchecked", "rawtypes" })
private static void assertDomainTypesDiscovered(MongoMappingContext mappingContext,
		Class<?>... types) {
	Set<Class> initialEntitySet = (Set<Class>) ReflectionTestUtils
			.getField(mappingContext, "initialEntitySet");
	assertThat(initialEntitySet).containsOnly(types);
}
 

import org.springframework.data.mongodb.core.mapping.MongoMappingContext; //导入依赖的package包/类
@Test
public void testDefaultRepositoryConfiguration() throws Exception {
	prepareApplicationContext(TestConfiguration.class);

	assertThat(this.context.getBean(CityRepository.class)).isNotNull();
	Mongo mongo = this.context.getBean(Mongo.class);
	assertThat(mongo).isInstanceOf(MongoClient.class);
	MongoMappingContext mappingContext = this.context
			.getBean(MongoMappingContext.class);
	@SuppressWarnings("unchecked")
	Set<? extends Class<?>> entities = (Set<? extends Class<?>>) ReflectionTestUtils
			.getField(mappingContext, "initialEntitySet");
	assertThat(entities).hasSize(1);
}