Java MappingMongoConverter.setTypeMapper方法代码示例

import org.springframework.data.mongodb.core.convert.MappingMongoConverter; //导入方法依赖的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.convert.MappingMongoConverter; //导入方法依赖的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.convert.MappingMongoConverter; //导入方法依赖的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.convert.MappingMongoConverter; //导入方法依赖的package包/类
@Bean
@Override
public MappingMongoConverter mappingMongoConverter() throws Exception {
    MappingMongoConverter mmc = super.mappingMongoConverter();
    //remove _class
    mmc.setTypeMapper(new DefaultMongoTypeMapper(null));
    return mmc;
}
 

import org.springframework.data.mongodb.core.convert.MappingMongoConverter; //导入方法依赖的package包/类
@Bean(name = "mongoTemplate")
public MongoTemplate createMongoTemplate() throws UnknownHostException {
    MongoClient mongoClient = new MongoClient(host, port);
    //TODO Configure additional MongoDB mongoClient settings if needed
    MongoDbFactory factory = new SimpleMongoDbFactory(mongoClient, database, new UserCredentials(username, password));
    MappingMongoConverter converter = new MappingMongoConverter(new DefaultDbRefResolver(factory), new MongoMappingContext());
    converter.setTypeMapper(new DefaultMongoTypeMapper(null));

    return new MongoTemplate(factory, converter);
}
 

import org.springframework.data.mongodb.core.convert.MappingMongoConverter; //导入方法依赖的package包/类
public
@Bean
MongoTemplate mongoTemplate() throws Exception {
    MappingMongoConverter converter = new MappingMongoConverter(new DefaultDbRefResolver(mongoDbFactory()),
            new MongoMappingContext());
    // remove _class
    converter.setTypeMapper(new DefaultMongoTypeMapper(null));

    return new MongoTemplate(mongoDbFactory(), converter);
}
 

import org.springframework.data.mongodb.core.convert.MappingMongoConverter; //导入方法依赖的package包/类
public

    @Bean
    MongoTemplate categoriesMongoTemplate() throws Exception {
        MongoClient client;
        client = getMongoClientForCategoriesDatabase();

        MongoDbFactory categoriesMongoDbFactory = new SimpleMongoDbFactory(client, database);
        MappingMongoConverter converter = new MappingMongoConverter(new DefaultDbRefResolver(categoriesMongoDbFactory),
                new MongoMappingContext());
        // remove _class
        converter.setTypeMapper(new DefaultMongoTypeMapper(null));

        return new MongoTemplate(categoriesMongoDbFactory, converter);
    }
 

import org.springframework.data.mongodb.core.convert.MappingMongoConverter; //导入方法依赖的package包/类
private MongoConverter getDefaultMongoConverter(MongoDbFactory factory) {
    MappingMongoConverter converter = new MappingMongoConverter(factory, new MongoMappingContext());
    converter.afterPropertiesSet();
    converter.setTypeMapper(new DefaultMongoTypeMapper(null));
    return converter;
}
 

import org.springframework.data.mongodb.core.convert.MappingMongoConverter; //导入方法依赖的package包/类
@Bean
public MappingMongoConverter mongoConverter() throws UnknownHostException {
    MappingMongoConverter converter = new MappingMongoConverter(mongoDbFactory(), mongoMappingContext());
    converter.setTypeMapper(mongoTypeMapper());
    return converter;
}
 

import org.springframework.data.mongodb.core.convert.MappingMongoConverter; //导入方法依赖的package包/类
@Bean
public MappingMongoConverter mappingMongoConverter() throws Exception {
    MappingMongoConverter converter = new MappingMongoConverter(mongoDbFactory(), mongoMappingContext());
    converter.setTypeMapper(mongoTypeMapper());
    return converter;
}
 

import org.springframework.data.mongodb.core.convert.MappingMongoConverter; //导入方法依赖的package包/类
/**
 * Create new instance of <code>LogEventMongoDao</code> using configuration instance of
 * <code>MongoDbConfig</code>.
 *
 * @param configuration the configuration of log event mongo dao, it contain server size,
 *                      credentials, max wait time, etc.
 */
@SuppressWarnings("deprecation")
public LogEventMongoDao(MongoDbConfig configuration) throws Exception {

  List<ServerAddress> seeds = new ArrayList<>(configuration.getMongoServers().size());
  for (MongoDbServer server : configuration.getMongoServers()) {
    seeds.add(new ServerAddress(server.getHost(), server.getPort()));
  }

  List<MongoCredential> credentials = new ArrayList<>();
  if (configuration.getMongoCredentials() != null) {
    for (MongoDBCredential credential : configuration.getMongoCredentials()) {
      credentials.add(MongoCredential.createMongoCRCredential(credential.getUser(),
          configuration.getDbName(),
          credential.getPassword().toCharArray()));
    }
  }

  MongoClientOptions.Builder optionsBuilder = new MongoClientOptions.Builder();
  if (configuration.getConnectionsPerHost() != null) {
    optionsBuilder.connectionsPerHost(configuration.getConnectionsPerHost());
  }
  if (configuration.getMaxWaitTime() != null) {
    optionsBuilder.maxWaitTime(configuration.getMaxWaitTime());
  }
  if (configuration.getConnectionTimeout() != null) {
    optionsBuilder.connectTimeout(configuration.getConnectionTimeout());
  }
  if (configuration.getSocketTimeout() != null) {
    optionsBuilder.socketTimeout(configuration.getSocketTimeout());
  }
  if (configuration.getSocketKeepalive() != null) {
    optionsBuilder.socketKeepAlive(configuration.getSocketKeepalive());
  }

  MongoClientOptions options = optionsBuilder.build();
  mongoClient = new MongoClient(seeds, credentials, options);

  MongoDbFactory dbFactory = new SimpleMongoDbFactory(mongoClient, configuration.getDbName());

  MappingMongoConverter converter = new MappingMongoConverter(dbFactory,
      new MongoMappingContext());
  converter.setTypeMapper(new DefaultMongoTypeMapper(null));

  mongoTemplate = new MongoTemplate(dbFactory, converter);
  mongoTemplate.setWriteResultChecking(WriteResultChecking.EXCEPTION);
}