Java MongoDbFactory类代码示例

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的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.MongoDbFactory; //导入依赖的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.MongoDbFactory; //导入依赖的package包/类
@Override
public MongoDbFactory mongoDbFactory() throws Exception {
	
	if (System.getenv("spring_eg_content_mongo_host") != null) {
    	String host = System.getenv("spring_eg_content_mongo_host");
    	String port = System.getenv("spring_eg_content_mongo_port");
    	String username = System.getenv("spring_eg_content_mongo_username");
    	String password = System.getenv("spring_eg_content_mongo_password");

		 // Set credentials      
	    MongoCredential credential = MongoCredential.createCredential(username, getDatabaseName(), password.toCharArray());
	    ServerAddress serverAddress = new ServerAddress(host, Integer.parseInt(port));

	    // Mongo Client
	    MongoClient mongoClient = new MongoClient(serverAddress,Arrays.asList(credential)); 

	    // Mongo DB Factory
	    return new SimpleMongoDbFactory(mongoClient, getDatabaseName());
	}
	return super.mongoDbFactory();
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
@Test
public void cloudMongoCreationNoConfig() throws Exception {
	MongoServiceInfo serviceInfo = new MongoServiceInfo("id", TEST_HOST, TEST_PORT, TEST_USERNAME, TEST_PASSWORD, TEST_DB);

	MongoDbFactory mongoDbFactory = testCreator.create(serviceInfo, null);

	assertNotNull(mongoDbFactory);

	MongoClient mongo = (MongoClient) ReflectionTestUtils.getField(mongoDbFactory, "mongo");
	assertNotNull(mongo);

	MongoCredential credentials = mongo.getCredentialsList().get(0);

	List<ServerAddress> addresses = extractServerAddresses(mongo);
	assertEquals(1, addresses.size());

	ServerAddress address = addresses.get(0);

	assertEquals(serviceInfo.getHost(), address.getHost());
	assertEquals(serviceInfo.getPort(), address.getPort());
	assertEquals(serviceInfo.getUserName(), credentials.getUserName());
	assertNotNull(credentials.getPassword());

	// Don't do connector.getDatabase().getName() as that will try to initiate the connection
	assertEquals(serviceInfo.getDatabase(), ReflectionTestUtils.getField(mongoDbFactory, "databaseName"));
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
@Test
public void cloudMongoCreationWithMultipleHostsByUri() throws Exception {
	String uri = String.format("%s://%s:%[email protected]%s:%s/%s", MONGODB_SCHEME, TEST_USERNAME, TEST_PASSWORD,
			StringUtils.arrayToDelimitedString(TEST_HOSTS, ","), TEST_PORT, TEST_DB);

	MongoServiceInfo serviceInfo = new MongoServiceInfo("id", uri);

	MongoDbFactory mongoDbFactory = testCreator.create(serviceInfo, null);

	assertNotNull(mongoDbFactory);

	MongoClient mongo = (MongoClient) ReflectionTestUtils.getField(mongoDbFactory, "mongo");
	assertNotNull(mongo);

	List<ServerAddress> addresses = extractServerAddresses(mongo);
	assertEquals(3, addresses.size());

	MongoCredential credentials = mongo.getCredentialsList().get(0);
	assertEquals(TEST_USERNAME, credentials.getUserName());
	assertNotNull(credentials.getPassword());

	// Don't do connector.getDatabase().getName() as that will try to initiate the connection
	assertEquals(TEST_DB, ReflectionTestUtils.getField(mongoDbFactory, "databaseName"));

	ServerAddress address1 = addresses.get(0);
	assertEquals(TEST_HOST, address1.getHost());
	assertEquals(TEST_PORT_DEFAULT, address1.getPort());

	ServerAddress address2 = addresses.get(1);
	assertEquals(TEST_HOST_1, address2.getHost());
	assertEquals(TEST_PORT_DEFAULT, address2.getPort());

	ServerAddress address3 = addresses.get(2);
	assertEquals(TEST_HOST_2, address3.getHost());
	assertEquals(TEST_PORT, address3.getPort());
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
@Test
public void cloudScanWithAllTypesOfServices() {
	ApplicationContext testContext = getTestApplicationContext(createMysqlService("mysqlDb"), 
															  createPostgresqlService("postDb"),
															  createMongoService("mongoDb"),
															  createRedisService("redisDb"),
															  createRabbitService("rabbit"));
	
	assertNotNull("Getting service by id", testContext.getBean("mysqlDb"));
	assertNotNull("Getting service by id and type", testContext.getBean("mysqlDb", DataSource.class));		

	assertNotNull("Getting service by id", testContext.getBean("postDb"));
	assertNotNull("Getting service by id and type", testContext.getBean("postDb", DataSource.class));		

	assertNotNull("Getting service by id", testContext.getBean("mongoDb"));
	assertNotNull("Getting service by id and type", testContext.getBean("mongoDb", MongoDbFactory.class));		
	
	assertNotNull("Getting service by id", testContext.getBean("redisDb"));
	assertNotNull("Getting service by id and type", testContext.getBean("redisDb", RedisConnectionFactory.class));		

	assertNotNull("Getting service by id", testContext.getBean("rabbit"));
	assertNotNull("Getting service by id and type", testContext.getBean("rabbit", ConnectionFactory.class));		
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
@RefreshScope
@Bean
public MongoDbFactory mongoDbGoogleAuthenticatorFactory() {
    try {
        final MultifactorAuthenticationProperties.GAuth.Mongodb mongo = casProperties.getAuthn().getMfa().getGauth().getMongodb();
        return new SimpleMongoDbFactory(new MongoClientURI(mongo.getClientUri()));
    } catch (final Exception e) {
        throw new BeanCreationException(e.getMessage(), e);
    }
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
@RefreshScope
@Bean
public MongoDbFactory mongoAuthNEventsDbFactory() {
    try {
        return new SimpleMongoDbFactory(new MongoClientURI(casProperties.getEvents().getMongodb().getClientUri()));
    } catch (final Exception e) {
        throw new BeanCreationException(e.getMessage(), e);
    }
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
@RefreshScope
@Bean
public MongoDbFactory mongoMfaTrustedAuthnDbFactory() {
    try {
        return new SimpleMongoDbFactory(new MongoClientURI(
                casProperties.getAuthn().getMfa().getTrusted().getMongodb().getClientUri()));
    } catch (final Exception e) {
        throw new BeanCreationException(e.getMessage(), e);
    }
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的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.MongoDbFactory; //导入依赖的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.MongoDbFactory; //导入依赖的package包/类
private String toString(MongoDbFactory mongoDbFactory) {
    if (mongoDbFactory == null) {
        return "<none>";
    } else {
        try {
            return mongoDbFactory.getDb().getMongo().getAddress().toString();
        } catch (Exception ex) {
            return "<invalid address> " + mongoDbFactory.getDb().getMongo().toString();
        }
    }
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
public
@Bean
MongoDbFactory mongoDbFactory() throws Exception {
    Resource resource = new ClassPathResource("/runtime.properties");
    Properties props = PropertiesLoaderUtils.loadProperties(resource);
    String uriStr = props.getProperty("mongo.url.dev", "");

    return new SimpleMongoDbFactory(new MongoClientURI(uriStr));
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
@Bean
@ConditionalOnMissingBean
public GridFsTemplate gridFsTemplate(MongoDbFactory mongoDbFactory,
		MongoTemplate mongoTemplate) {
	return new GridFsTemplate(
			new GridFsMongoDbFactory(mongoDbFactory, this.properties),
			mongoTemplate.getConverter());
}
 

import org.springframework.data.mongodb.MongoDbFactory; //导入依赖的package包/类
@Bean
public MongoDbFactory mongoDbFactory() throws Exception {
  MongoClientURI uri = new MongoClientURI(mongoDbUrl);
  mongo = new MongoClient(uri);
  mongo.setReadPreference(ReadPreference.primary());
  mongo.setWriteConcern(WriteConcern.ACKNOWLEDGED);
  return new SimpleMongoDbFactory(mongo, uri.getDatabase());
}