Java MongoTemplate类代码示例

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
/**
 * update v5: {@link UserDocument} has changed; String-Field 'email' was replaced with custom Type 'Email'.
 * find all user with an email String-value, replace String-Type with Custom-Type and update all UserDocuments.
 * if email-Field is Empty or null, you don't have to update user.
 *
 * @since V6
 */
@ChangeSet(order = "006", id = "updateUserChangeEmailFromStringToCustomClass", author = "admin")
public void updateUserChangeEmailField(final MongoTemplate template) {
  final Criteria isEmptyCriteria = new Criteria().orOperator(Criteria.where("email").is(""), Criteria.where("email").is(null));
  while (true) {
    final UserDocument result = template.findAndModify(new Query(isEmptyCriteria), Update.update("email", new Email()), UserDocument.class);
    if (result == null)
      break;
  }

  /**
   * if email not null -> Field will be cast to specific class and updates will create correct entries
   */
  // final Criteria isNotEmptyCriteria = new Criteria().orOperator(Criteria.where("email").ne(""), Criteria.where("email").ne(null));
  // final List<UserDocument> userDocumentList = template.find(new Query(isNotEmptyCriteria), UserDocument.class);

}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
/**
 * update 6: {@link UserDocument} has changed; 'name' and 'surname' will be concat to 'name'.
 * for each every user document get 'name' and 'surname', concat them, update 'name', remove field surname and update document.
 *
 * @since V7
 */
@ChangeSet(order = "008", id = "updateUserChangeNameAndSurnameToName", author = "admin")
public void updateUserChangeNameAndSurnametoName(final MongoTemplate template) {
  final DBCollection userCollection = template.getCollection("user");

  final Iterator<DBObject> cursor = userCollection.find();
  while (cursor.hasNext()) {
    final DBObject current = cursor.next();

    final Object nameObj = current.get("name");
    final Object surnameObj = current.get("surname");
    final String updateName = (nameObj != null ? nameObj.toString() : "") + " " + (surnameObj != null ? surnameObj.toString() : "");

    final BasicDBObject updateQuery = new BasicDBObject();
    updateQuery.append("$set", new BasicDBObject("name", updateName));
    updateQuery.append("$unset", new BasicDBObject("surname", ""));

    final BasicDBObject searchQuery = new BasicDBObject();
    searchQuery.put("_id", current.get("_id"));

    userCollection.update(searchQuery, updateQuery);
  }
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
@ChangeSet(order = "02", author = "initiator", id = "02-addUsers")
public void addUsers(MongoTemplate mongoTemplate) {
    Authority adminAuthority = new Authority();
    adminAuthority.setName(AuthoritiesConstants.ADMIN);
    Authority userAuthority = new Authority();
    userAuthority.setName(AuthoritiesConstants.USER);

    User adminUser = new User();
    adminUser.setId("user-0");
    adminUser.setLogin("admin");
    adminUser.setPassword("$2a$10$gSAhZrxMllrbgj/kkK9UceBPpChGWJA7SYIb1Mqo.n5aNLq1/oRrC");
    adminUser.setFirstName("admin");
    adminUser.setLastName("Administrator");
    adminUser.setEmail("[email protected]");
    adminUser.setActivated(true);
    adminUser.setLangKey("en");
    adminUser.getAuthorities().add(userAuthority);
    adminUser.setCreatedBy(adminUser.getLogin());
    adminUser.setCreatedDate(ZonedDateTime.now());
    adminUser.setLastModifiedBy(adminUser.getLogin());
    adminUser.setLastModifiedDate(ZonedDateTime.now());
    mongoTemplate.save(adminUser);
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
@Test
public void verifyEmbeddedConfigurationContext() {
    final PropertyPlaceholderConfigurer configurer = new PropertyPlaceholderConfigurer();
    final Properties properties = new Properties();
    properties.setProperty("mongodb.host", "ds061954.mongolab.com");
    properties.setProperty("mongodb.port", "61954");
    properties.setProperty("mongodb.userId", "casuser");
    properties.setProperty("mongodb.userPassword", "Mellon");
    properties.setProperty("cas.service.registry.mongo.db", "jasigcas");
    configurer.setProperties(properties);

    final FileSystemXmlApplicationContext ctx = new FileSystemXmlApplicationContext(
            new String[]{"src/main/resources/META-INF/spring/mongo-services-context.xml"}, false);
    ctx.getBeanFactoryPostProcessors().add(configurer);
    ctx.refresh();

    final MongoServiceRegistryDao dao = new MongoServiceRegistryDao();
    dao.setMongoTemplate(ctx.getBean("mongoTemplate", MongoTemplate.class));
    cleanAll(dao);
    assertTrue(dao.load().isEmpty());
    saveAndLoad(dao);
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
/**
 * update v3: {@link UserDocument} has changed; an embedded Document 'address' was added.
 *
 * @since V4
 */
@ChangeSet(order = "004", id = "addAddressToUser", author = "admin")
public void updateUserAddAddress(final MongoTemplate template) {
  final List<UserDocument> userList = template.find(Query.query(Criteria.where("email").is("[email protected]")), UserDocument.class);
  userList.stream()
      .map(userDocument -> {
        userDocument.getUserAddress()
            .addAll(
                Stream.iterate(0, n -> n + 1)
                    .limit(new Random().nextInt(5))
                    .map(it -> new Address("Hamburger City", "Random Muster Straße " + it, it + "5678"))
                    .collect(Collectors.toList()));
        return userDocument;
      })
      .forEach(template::save);
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
@Bean
public Function<ProjectEventParam, Map<String, Object>> function(MongoTemplate template) {
    return projectEventParam -> {
        // Extract parameters from the event before processing
        Map<String, Object> result = new HashMap<>();
        result.put("updated", new ArrayList<String>());
        result.put("inserted", new ArrayList<String>());
        result.put("events", new ArrayList<TightCouplingEvent>());

        Project project = projectEventParam.getProject();
        ProjectEvent event = projectEventParam.getProjectEvent();
        Commit commit = event.getPayload().getOrDefault("commit", null);

        // If a commit exists and has files, create a view processor to generate query model updates
        if (commit != null) {
            TightCouplingProcessor tightCouplingProcessor = new TightCouplingProcessor(event, project, commit);
            List<View> viewList = tightCouplingProcessor.generateView();

            // Insert or update query models produced from the event
            upsertViewList(viewList, template, result);
        }

        // Returns back a list of inserted and updated keys
        return result;
    };
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
/** The mongodb ops. */

	/* (non-Javadoc)
	 * @see co.aurasphere.botmill.core.datastore.adapter.DataAdapter#setup()
	 */
	public void setup() {
		
		MongoCredential credential = MongoCredential.createCredential(
				ConfigurationUtils.getEncryptedConfiguration().getProperty("mongodb.username"), 
				ConfigurationUtils.getEncryptedConfiguration().getProperty("mongodb.database"), 
				ConfigurationUtils.getEncryptedConfiguration().getProperty("mongodb.password").toCharArray());
		ServerAddress serverAddress = new ServerAddress(
				ConfigurationUtils.getEncryptedConfiguration().getProperty("mongodb.server"), 
				Integer.valueOf(ConfigurationUtils.getEncryptedConfiguration().getProperty("mongodb.port")));
		MongoClient mongoClient = new MongoClient(serverAddress, Arrays.asList(credential));
		SimpleMongoDbFactory simpleMongoDbFactory = new SimpleMongoDbFactory(mongoClient, ConfigurationUtils.getEncryptedConfiguration().getProperty("mongodb.database"));

		MongoTemplate mongoTemplate = new MongoTemplate(simpleMongoDbFactory);
		this.source = (MongoOperations) mongoTemplate;
	}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
@Test
public void defaultRepo() {
	// Prepare context
	Map<String, Object> props = new HashMap<>();
	props.put("spring.data.mongodb.database", "testdb");
	context = new SpringApplicationBuilder(TestConfiguration.class).web(false).properties(props).run();
	// Prepare test
	MongoTemplate mongoTemplate = this.context.getBean(MongoTemplate.class);
	mongoTemplate.dropCollection("testapp");
	MongoPropertySource ps = new MongoPropertySource();
	ps.getSource().put("testkey", "testval");
	mongoTemplate.save(ps, "testapp");
	// Test
	EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class);
	Environment environment = repository.findOne("testapp", "default", null);
	assertEquals("testapp-default", environment.getPropertySources().get(0).getName());
	assertEquals(1, environment.getPropertySources().size());
	assertEquals(true, environment.getPropertySources().get(0).getSource().containsKey("testkey"));
	assertEquals("testval", environment.getPropertySources().get(0).getSource().get("testkey"));
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
@Test
public void nestedPropertySource() {
	// Prepare context
	Map<String, Object> props = new HashMap<>();
	props.put("spring.data.mongodb.database", "testdb");
	context = new SpringApplicationBuilder(TestConfiguration.class).web(false).properties(props).run();
	// Prepare test
	MongoTemplate mongoTemplate = this.context.getBean(MongoTemplate.class);
	mongoTemplate.dropCollection("testapp");
	MongoPropertySource ps = new MongoPropertySource();
	Map<String, String> inner = new HashMap<String, String>();
	inner.put("inner", "value");
	ps.getSource().put("outer", inner);
	mongoTemplate.save(ps, "testapp");
	// Test
	EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class);
	Environment environment = repository.findOne("testapp", "default", null);
	assertEquals("testapp-default", environment.getPropertySources().get(0).getName());
	assertEquals(1, environment.getPropertySources().size());
	assertEquals(true, environment.getPropertySources().get(0).getSource().containsKey("outer.inner"));
	assertEquals("value", environment.getPropertySources().get(0).getSource().get("outer.inner"));
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
@Test
public void repoWithProfileAndLabelInSource() {
	// Prepare context
	Map<String, Object> props = new HashMap<>();
	props.put("spring.data.mongodb.database", "testdb");
	context = new SpringApplicationBuilder(TestConfiguration.class).web(false).properties(props).run();
	// Prepare test
	MongoTemplate mongoTemplate = this.context.getBean(MongoTemplate.class);
	mongoTemplate.dropCollection("testapp");
	MongoPropertySource ps = new MongoPropertySource();
	ps.setProfile("confprofile");
	ps.setLabel("conflabel");
	ps.getSource().put("profile", "sourceprofile");
	ps.getSource().put("label", "sourcelabel");
	mongoTemplate.save(ps, "testapp");
	// Test
	EnvironmentRepository repository = this.context.getBean(EnvironmentRepository.class);
	Environment environment = repository.findOne("testapp", "confprofile", "conflabel");
	assertEquals(1, environment.getPropertySources().size());
	assertEquals("testapp-confprofile-conflabel", environment.getPropertySources().get(0).getName());
	assertEquals(true, environment.getPropertySources().get(0).getSource().containsKey("profile"));
	assertEquals("sourceprofile", environment.getPropertySources().get(0).getSource().get("profile"));
	assertEquals(true, environment.getPropertySources().get(0).getSource().containsKey("label"));
	assertEquals("sourcelabel", environment.getPropertySources().get(0).getSource().get("label"));
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
@Test
public void shouldGetInstanceRepositoryWork()
		throws NoSuchFieldException, SecurityException, IllegalArgumentException, IllegalAccessException {

	// workaround to get valid impl template
	Field f = tenantLogRepository.getClass().getDeclaredField("mongoAuditTemplate");
	f.setAccessible(true);
	MongoTemplate mongoTemplate = (MongoTemplate) f.get(tenantLogRepository);

	TenantLogRepository repository = TenantLogRepository.getInstance();

	// workaround to set impl template
	Field fSet = repository.getClass().getDeclaredField("mongoAuditTemplate");
	fSet.setAccessible(true);
	fSet.set(repository, mongoTemplate);

	repository.insert("YJgQ8Zj2j0", new Date().getTime(), "WARN", "H5ITwKKqrm");

}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
private MongoTemplate getMongoTemplate(String host, int port,
                                       String authenticationDB,//TODO: is it redundant ?
                                       String database,
                                       String user, char[] password)
        throws UnknownHostException {
    return new MongoTemplate(
            new SimpleMongoDbFactory(
                    new MongoClient(
                            new ServerAddress(host, port),
                            Collections.singletonList(
                                    MongoCredential.createCredential(
                                            user,
                                            authenticationDB,
                                            password
                                    )
                            )
                    ),
                    database
            )
    );
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
private void assertVersionConfiguration(String configuredVersion,
		String expectedVersion) {
	this.context = new AnnotationConfigApplicationContext();
	int mongoPort = SocketUtils.findAvailableTcpPort();
	EnvironmentTestUtils.addEnvironment(this.context,
			"spring.data.mongodb.port=" + mongoPort);
	if (configuredVersion != null) {
		EnvironmentTestUtils.addEnvironment(this.context,
				"spring.mongodb.embedded.version=" + configuredVersion);
	}
	this.context.register(MongoAutoConfiguration.class,
			MongoDataAutoConfiguration.class, EmbeddedMongoAutoConfiguration.class);
	this.context.refresh();
	MongoTemplate mongo = this.context.getBean(MongoTemplate.class);
	CommandResult buildInfo = mongo.executeCommand("{ buildInfo: 1 }");

	assertThat(buildInfo.getString("version")).isEqualTo(expectedVersion);
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
private void assertVersionConfiguration(String configuredVersion,
		String expectedVersion) {
	this.context = new AnnotationConfigApplicationContext();
	int mongoPort = SocketUtils.findAvailableTcpPort();
	EnvironmentTestUtils.addEnvironment(this.context,
			"spring.data.mongodb.port=" + mongoPort);
	if (configuredVersion != null) {
		EnvironmentTestUtils.addEnvironment(this.context,
				"spring.mongodb.embedded.version=" + configuredVersion);
	}
	this.context.register(MongoAutoConfiguration.class,
			MongoDataAutoConfiguration.class, EmbeddedMongoAutoConfiguration.class);
	this.context.refresh();
	MongoTemplate mongo = this.context.getBean(MongoTemplate.class);
	CommandResult buildInfo = mongo.executeCommand("{ buildInfo: 1 }");

	assertThat(buildInfo.getString("version"), equalTo(expectedVersion));
}
 

import org.springframework.data.mongodb.core.MongoTemplate; //导入依赖的package包/类
@Test
public void testUnReserveWithValidDevice() {
    MongoTemplate mockMongoTemplate = EasyMock.createMock(MongoTemplate.class);
    PersistableDevice persistableDev = EasyMock.createMock(PersistableDevice.class);

    DawgPoundMongoService dawgPoundService = new DawgPoundMongoService();
    ReflectionTestUtils.setField(dawgPoundService, "mongoTemplate", mockMongoTemplate);

    EasyMock.expect(mockMongoTemplate.findById(TestConstants.DEVICE_ID, PersistableDevice.class, TestConstants.COLLECTION_NAME )).andReturn(persistableDev);
    EasyMock.expect(persistableDev.unreserve()).andReturn(TestConstants.TOKEN);
    mockMongoTemplate.save(persistableDev, TestConstants.COLLECTION_NAME);

    EasyMock.replay(mockMongoTemplate, persistableDev);
    Assert.assertEquals(dawgPoundService.unreserve(TestConstants.DEVICE_ID), TestConstants.TOKEN);
    EasyMock.verify(mockMongoTemplate, persistableDev);
}