下面列出了怎么用com.mongodb.MongoClientOptions的API类实例代码及写法,或者点击链接到github查看源代码。
public Schema create(SchemaPlus parentSchema, String name,
Map<String, Object> operand) {
final String host = (String) operand.get("host");
final Integer port = Integer.valueOf(operand.get("port").toString());
final String database = (String) operand.get("dbName");
final String authMechanismName = (String) operand.get("authMechanism");
final MongoClientOptions.Builder options = MongoClientOptions.builder();
final List<MongoCredential> credentials = new ArrayList<>();
if (authMechanismName != null) {
final MongoCredential credential = createCredentials(operand);
credentials.add(credential);
}
return new MongoSchema(host, port,database, credentials, options.build());
}
@Override
public void afterPropertiesSet() {
try {
long time1, time2;
time1 = System.currentTimeMillis();
MongoClientOptions options = MongoClientOptions.builder()
.connectionsPerHost(ApiContext.maxAliveConnect)
.threadsAllowedToBlockForConnectionMultiplier(ApiContext.maxAliveConnect)
.socketTimeout(ApiContext.socketTimeout)
.maxWaitTime(ApiContext.maxWaitTime)
.connectTimeout(ApiContext.connectTimeOut)
.build();
ServerAddress serverAddress = new ServerAddress(ApiContext.databaseUrl, ApiContext.databasePort);
MongoClient mongoClient = new MongoClient(serverAddress, options);
MongoDatabase mongoDatabase = mongoClient.getDatabase(DATABASE_NAME);
mongoDatabase.getCollection(TEST_TABLE).drop();
time2 = System.currentTimeMillis();
LoggerUtil.commonLog.info("------connect mongodb use time:" + (time2 - time1));
this.client = mongoClient;
this.db = mongoDatabase;
} catch (Exception e) {
LoggerUtil.commonLog.error(e);
System.exit(-1);
}
}
public MongoDbFactory mongoDbFactory(MongoClientOptionProperties properties) {
//创建客户端参数
MongoClientOptions options = mongoClientOptions(properties);
//创建客户端和Factory
List<ServerAddress> serverAddresses = new ArrayList<>();
for (String address : properties.getAddress()) {
String[] hostAndPort = address.split(":");
String host = hostAndPort[0];
int port = Integer.parseInt(hostAndPort[1]);
ServerAddress serverAddress = new ServerAddress(host, port);
serverAddresses.add(serverAddress);
}
//创建认证客户端
MongoCredential mongoCredential = MongoCredential
.createScramSha1Credential(
properties.getUsername(),
properties.getAuthenticationDatabase() != null ? properties.getAuthenticationDatabase() : properties.getDatabase(),
properties.getPassword().toCharArray()
);
MongoClient mongoClient = new MongoClient(serverAddresses, mongoCredential, options);
return new SimpleMongoDbFactory(mongoClient, properties.getDatabase());
}
public HelperMongo(@Nonnull MongoDatabaseCredentials credentials) {
MongoCredential mongoCredential = MongoCredential.createCredential(
credentials.getUsername(),
credentials.getDatabase(),
credentials.getPassword().toCharArray()
);
this.client = new MongoClient(
new ServerAddress(credentials.getAddress(), credentials.getPort()),
mongoCredential,
MongoClientOptions.builder().build()
);
this.database = this.client.getDatabase(credentials.getDatabase());
this.morphia = new Morphia();
this.morphiaDatastore = this.morphia.createDatastore(this.client, credentials.getDatabase());
this.morphia.getMapper().getOptions().setObjectFactory(new DefaultCreator() {
@Override
protected ClassLoader getClassLoaderForClass() {
return LoaderUtils.getPlugin().getClassloader();
}
});
}
private MongoClient createClient(AbstractConfig config, MongoClientOptions options) {
String host = config.getString(MONGO_HOST);
int port = config.getInt(MONGO_PORT);
try {
MongoClientOptions actualOptions;
if (options != null) {
actualOptions = options;
} else {
actualOptions = new MongoClientOptions.Builder().build();
}
ServerAddress server = new ServerAddress(host, port);
if (credentials != null) {
return new MongoClient(server, credentials, actualOptions);
} else {
return new MongoClient(server, actualOptions);
}
} catch (MongoException ex) {
log.error("Failed to create MongoDB client to {}:{} with credentials {}", host, port,
credentials, ex);
throw new ConnectException("MongoDb client cannot be created.", ex);
}
}
private Map<String, Method> createSettingsMap() {
final Map<String, Method> settingsMap = new HashMap<>();
final Method[] methods = MongoClientOptions.Builder.class.getDeclaredMethods();
for (final Method method : methods) {
if (method.getParameterTypes().length == 1) {
final Class<?> parameterType = method.getParameterTypes()[0];
// only int, string and boolean
if (int.class.equals(parameterType) || String.class.equals(parameterType) || boolean.class.equals(parameterType)) {
settingsMap.put(method.getName(), method);
}
}
}
return settingsMap;
}
private void prepareClient() {
try {
ServerAddress address = new ServerAddress(config.getMongo().getHost(), config.getMongo().getPort());
MongoClientOptions options = MongoClientOptions.builder()
.serverSelectionTimeout(5000)
.socketKeepAlive(false)
.readPreference(ReadPreference.primaryPreferred())
.sslInvalidHostNameAllowed(true)
.build();
client = connectToClient(address, options);
} catch (Exception ex) {
logger.error(ex.getMessage(), ex);
System.exit(-1);
}
}
@Bean
public MongoClient mongo() throws UnknownHostException {
// location of db
ServerAddress sa = new ServerAddress(
environment.getProperty("mongodb.host"),
environment.getProperty("mongodb.port", Integer.class)
);
// set optional default parameters here
MongoClientOptions.Builder builder = MongoClientOptions.builder();
// none yet
MongoClientOptions options = builder.build();
return new MongoClient(sa, options);
}
@Inject
public MongoClientWrapper(MongoClientConfiguration configuration) throws
UnreachableMongoServerException {
try {
MongoClientOptions options = toMongoClientOptions(configuration);
ImmutableList<MongoCredential> credentials = toMongoCredentials(configuration);
testAddress(configuration.getHostAndPort(), options);
this.configuration = configuration;
this.driverClient = new com.mongodb.MongoClient(
new ServerAddress(
configuration.getHostAndPort().getHostText(),
configuration.getHostAndPort().getPort()),
credentials,
options
);
version = calculateVersion();
codecRegistry = CodecRegistries.fromCodecs(new DocumentCodec());
closed = false;
} catch (com.mongodb.MongoException ex) {
throw new UnreachableMongoServerException(configuration.getHostAndPort(), ex);
}
}
public Schema create(SchemaPlus parentSchema, String name,
Map<String, Object> operand) {
final String host = (String) operand.get("host");
final String database = (String) operand.get("database");
final String authMechanismName = (String) operand.get("authMechanism");
final MongoClientOptions.Builder options = MongoClientOptions.builder();
final MongoCredential credential;
if (authMechanismName != null) {
credential = createCredential(operand);
} else {
credential = null;
}
return new MongoSchema(host, database, credential, options.build());
}
private static MongoClientURI getMongoURI( Properties connProps,
MongoClientOptions.Builder clientOptionsBuilder ) throws Exception
{
// check if explicitly indicated not to use URI, even if URI value exists
Boolean ignoreURI = getBooleanPropValue( connProps, IGNORE_URI_PROP );
if( ignoreURI != null && ignoreURI )
return null;
String uri = getStringPropValue( connProps, MONGO_URI_PROP );
if( uri == null || uri.isEmpty() )
return null;
try
{
if ( clientOptionsBuilder != null )
{
return new MongoClientURI( uri, clientOptionsBuilder );
}
else
{
return new MongoClientURI( uri );
}
}
catch( Exception ex )
{
// log and ignore
getLogger().log( Level.INFO, Messages.bind( "Invalid Mongo Database URI: {0}", uri ), ex ); //$NON-NLS-1$
throw ex;
}
//return null;
}
@Singleton
@Provides
public static MongoSession createMongoSession(TypeManager typeManager, MongoClientConfig config)
{
requireNonNull(config, "config is null");
MongoClientOptions.Builder options = MongoClientOptions.builder();
options.connectionsPerHost(config.getConnectionsPerHost())
.connectTimeout(config.getConnectionTimeout())
.socketTimeout(config.getSocketTimeout())
.socketKeepAlive(config.getSocketKeepAlive())
.sslEnabled(config.getSslEnabled())
.maxWaitTime(config.getMaxWaitTime())
.minConnectionsPerHost(config.getMinConnectionsPerHost())
.readPreference(config.getReadPreference().getReadPreference())
.writeConcern(config.getWriteConcern().getWriteConcern());
if (config.getRequiredReplicaSetName() != null) {
options.requiredReplicaSetName(config.getRequiredReplicaSetName());
}
MongoClient client = new MongoClient(config.getSeeds(), config.getCredentials(), options.build());
return new MongoSession(
typeManager,
client,
config);
}
@Produces
public MongoClient createMongo() {
System.out.println("Create mongo with host=" + MONGO_HOSTNAME + " port=" + MONGO_PORT);
return new MongoClient(new ServerAddress(MONGO_HOSTNAME, MONGO_PORT), //
new MongoClientOptions.Builder()
.connectTimeout(5000)
.maxWaitTime(5000)
.build());
}
/**
* Creates a MongoDB schema.
*
* @param host Mongo host, e.g. "localhost"
* @param credentialsList Optional credentials (empty list for none)
* @param options Mongo connection options
* @param database Mongo database name, e.g. "foodmart"
*/
MongoSchema(String host,Integer port, String database,
List<MongoCredential> credentialsList, MongoClientOptions options) {
super();
try {
final MongoClient mongo =
new MongoClient(new ServerAddress(host,port), credentialsList, options);
this.mongoDb = mongo.getDatabase(database);
} catch (Exception e) {
throw new RuntimeException(e);
}
}
/**
* @decription 初始化配置
* @author yi.zhang
* @time 2017年6月2日 下午2:15:57
*/
public void init(String servers,String database,String schema,String username,String password) {
try {
List<ServerAddress> saddress = new ArrayList<ServerAddress>();
if (servers != null && !"".equals(servers)) {
for (String server : servers.split(",")) {
String[] address = server.split(":");
String ip = address[0];
int port = 27017;
if (address != null && address.length > 1) {
port = Integer.valueOf(address[1]);
}
saddress.add(new ServerAddress(ip, port));
}
}
MongoCredential credential = MongoCredential.createScramSha1Credential(username, database,password.toCharArray());
List<MongoCredential> credentials = new ArrayList<MongoCredential>();
credentials.add(credential);
Builder builder = new MongoClientOptions.Builder();
builder.maxWaitTime(MAX_WAIT_TIME);
// 通过连接认证获取MongoDB连接
MongoClient client = new MongoClient(saddress, credentials, builder.build());
// 连接到数据库
session = client.getDatabase(schema);
} catch (Exception e) {
logger.error("-----MongoDB Config init Error-----", e);
}
}
public static void main(String[] args ) {
LOG.info("MongoDB demo starting ...");
CodecRegistry pojoCodecRegistry = fromRegistries(MongoClient.getDefaultCodecRegistry(),
fromProviders(PojoCodecProvider.builder().automatic(true).build()));
MongoClient mongoClient = new MongoClient( Utils.SERVER_HOSTNAME, MongoClientOptions.builder().codecRegistry(pojoCodecRegistry).build());
MongoDatabase database = mongoClient.getDatabase(Utils.DB_NAME);
RoleService roleService = new RoleServiceImpl(database);
Collection<Role> roles = roleService.getRoles();
LOG.info("Roles: {}", roles.size());
LOG.info("MongoDB demo done.");
}
@BeforeClass
public void init() throws DataException {
CodecRegistry pojoCodecRegistry = fromRegistries(MongoClient.getDefaultCodecRegistry(),
fromProviders(PojoCodecProvider.builder().automatic(true).build()));
mongoClient = new MongoClient( Utils.SERVER_HOSTNAME, MongoClientOptions.builder().codecRegistry(pojoCodecRegistry).build());
database = mongoClient.getDatabase(Utils.DB_NAME);
roleService = new RoleServiceImpl(database);
roleService.removeAll();
}
@Bean
public MongoClientOptions mongoClientOptions(MongoOptionProperties mongoOptionProperties) {
if (mongoOptionProperties == null) {
return new MongoClientOptions.Builder().build();
}
return new MongoClientOptions.Builder()
.minConnectionsPerHost(mongoOptionProperties.getMinConnectionPerHost())
.connectionsPerHost(mongoOptionProperties.getMaxConnectionPerHost())
.threadsAllowedToBlockForConnectionMultiplier(mongoOptionProperties.getThreadsAllowedToBlockForConnectionMultiplier())
.serverSelectionTimeout(mongoOptionProperties.getServerSelectionTimeout())
.maxWaitTime(mongoOptionProperties.getMaxWaitTime())
.maxConnectionIdleTime(mongoOptionProperties.getMaxConnectionIdleTime())
.maxConnectionLifeTime(mongoOptionProperties.getMaxConnectionLifeTime())
.connectTimeout(mongoOptionProperties.getConnectTimeout())
.socketTimeout(mongoOptionProperties.getSocketTimeout())
.socketKeepAlive(mongoOptionProperties.getSocketKeepAlive())
.sslEnabled(mongoOptionProperties.getSslEnabled())
.sslInvalidHostNameAllowed(mongoOptionProperties.getSslInvalidHostNameAllowed())
.alwaysUseMBeans(mongoOptionProperties.getAlwaysUseMBeans())
.heartbeatFrequency(mongoOptionProperties.getHeartbeatFrequency())
.minConnectionsPerHost(mongoOptionProperties.getMinConnectionPerHost())
.heartbeatConnectTimeout(mongoOptionProperties.getHeartbeatConnectTimeout())
.heartbeatSocketTimeout(mongoOptionProperties.getSocketTimeout())
.localThreshold(mongoOptionProperties.getLocalThreshold())
.build();
}
private String getReadPreference(Object arg) {
if (!(arg instanceof MongoClientOptions)) {
return null;
}
final MongoClientOptions mongoClientOptions = (MongoClientOptions) arg;
return mongoClientOptions.getReadPreference().getName();
}
@BeforeEach
void setup() {
registry = new SimpleMeterRegistry();
clusterId = new AtomicReference<>();
MongoClientOptions options = MongoClientOptions.builder()
.addCommandListener(new MongoMetricsCommandListener(registry))
.addClusterListener(new ClusterListenerAdapter() {
@Override
public void clusterOpening(ClusterOpeningEvent event) {
clusterId.set(event.getClusterId().getValue());
}
}).build();
mongo = new MongoClient(new ServerAddress(HOST, port), options);
}
@Test
public void testWithOptions(){
//set connection pool size to 200. the default is 100.
MongoClientOptions options = MongoClientOptions.builder().connectionsPerHost(200).build();
connectDBWithOptions(options);
//do query here
disconnectDB();
}
@Produces
public MongoClient createMongo() {
System.out.println("Create mongo with host=" + MONGO_HOSTNAME + " port=" + MONGO_PORT);
return new MongoClient(new ServerAddress(MONGO_HOSTNAME, MONGO_PORT), //
new MongoClientOptions.Builder()
.connectTimeout(5000)
.maxWaitTime(5000)
.build());
}
@Override
public MongoClient mongoClient() {
if (DbSetting.AUTHENTICATION_STATUS) {
return new MongoClient(
new ServerAddress(DbSetting.MONGODB_HOST, DbSetting.MONGODB_PORT),
MongoCredential.createCredential(DbSetting.DATABASE_USERNAME, getDatabaseName(), DbSetting.DATABASE_PASSWORD.toCharArray()),
MongoClientOptions.builder().build()
);
} else {
return new MongoClient(new ServerAddress(DbSetting.MONGODB_HOST, DbSetting.MONGODB_PORT));
}
}
private String getWriteConcern(Object arg) {
if (!(arg instanceof MongoClientOptions)) {
return null;
}
final MongoClientOptions mongoClientOptions = (MongoClientOptions) arg;
return MongoUtil.getWriteConcern0(mongoClientOptions.getWriteConcern());
}
@Bean
public MongoClientOptions optionsProvider() {
MongoClientOptions.Builder optionsBuilder = new MongoClientOptions.Builder();
optionsBuilder.serverSelectionTimeout(10000);
MongoClientOptions options = optionsBuilder.build();
return options;
}
@Override
public void create(JSONObject config) {
String key = config.getString("key");
if (mongos.containsKey(key))
return;
String schema = config.getString("schema");
if (validator.isEmpty(schema))
throw new NullPointerException("未设置schema值[" + config + "]!");
JSONArray array = config.getJSONArray("ips");
if (array == null || array.size() == 0)
throw new NullPointerException("未设置ips值[" + config + "]!");
String username = config.getString("username");
String password = config.getString("password");
boolean ssl = json.hasTrue(config, "ssl");
MongoClientOptions.Builder builder = MongoClientOptions.builder().connectionsPerHost(maxActive).maxWaitTime(maxWait);
List<MongoClient> list = new ArrayList<>();
for (int i = 0; i < array.size(); i++)
list.add(new MongoClient(new MongoClientURI("mongodb://" + username + ":" + password + "@" + array.getString(i)
+ "/" + schema + (ssl ? "?ssl=true" : ""), builder)));
schemas.put(key, schema);
mongos.put(key, list);
if (logger.isDebugEnable())
logger.debug("Mongo数据库[{}]初始化完成。", config);
}
@Override
public void init() {
if (!Strings.isNullOrEmpty(this.connectionUri)) {
this.mongoClient = new MongoClient(new MongoClientURI(this.connectionUri));
} else {
MongoCredential credential = null;
if (!Strings.isNullOrEmpty(this.configuration.getUsername())) {
credential = MongoCredential.createCredential(
this.configuration.getUsername(),
this.configuration.getDatabase(),
Strings.isNullOrEmpty(this.configuration.getPassword()) ? null : this.configuration.getPassword().toCharArray()
);
}
String[] addressSplit = this.configuration.getAddress().split(":");
String host = addressSplit[0];
int port = addressSplit.length > 1 ? Integer.parseInt(addressSplit[1]) : 27017;
ServerAddress address = new ServerAddress(host, port);
if (credential == null) {
this.mongoClient = new MongoClient(address);
} else {
this.mongoClient = new MongoClient(address, credential, MongoClientOptions.builder().build());
}
}
this.database = this.mongoClient.getDatabase(this.configuration.getDatabase());
}
@Test
public void test() throws Exception {
BuguConnection conn = BuguFramework.getInstance().createConnection();
conn.setHost("192.168.1.179");
conn.setPort(27017);
conn.setUsername("test");
conn.setPassword("test");
conn.setDatabase("test");
SSLContext sslContext = getSSLContext();
MongoClientOptions options = MongoClientOptions.builder()
.sslEnabled(true)
.sslContext(sslContext)
.sslInvalidHostNameAllowed(true)
.build();
conn.setOptions(options);
conn.connect();
System.out.println("SSL Connect success!");
FooDao dao = new FooDao();
Foo f = new Foo();
f.setName("f_1");
dao.save(f);
System.out.println("Save success!");
System.out.println("Foo Id: " + f.getId());
BuguFramework.getInstance().destroy();
}
@Test
public void checkConnectionWithoutCredentials() throws Exception {
Map<String, Object> configMap = new HashMap<>();
configMap.put(MONGO_USERNAME, null);
configMap.put(MONGO_PASSWORD, null);
configMap.put(MONGO_PORT, MONGO_PORT_DEFAULT + 1000);
configMap.put(MONGO_HOST, "localhost");
configMap.put(MONGO_DATABASE, "mydb");
configMap.put(COLLECTION_FORMAT, "{$topic}");
configMap.put(TOPICS_CONFIG, "a");
Field credentialsField = MongoWrapper.class.getDeclaredField("credentials");
credentialsField.setAccessible(true);
MongoClientOptions timeout = MongoClientOptions.builder()
.connectTimeout(1)
.socketTimeout(1)
.serverSelectionTimeout(1)
.build();
MongoWrapper wrapper = new MongoWrapper(new AbstractConfig(CONFIG_DEF, configMap), timeout);
assertThat(credentialsField.get(wrapper), is(nullValue()));
assertFalse(wrapper.checkConnection());
thrown.expect(MongoException.class);
try {
wrapper.store("mytopic", new Document());
} finally {
wrapper.close();
}
}
@Test
public void checkConnectionWithCredentials() throws Exception {
Map<String, Object> configMap = new HashMap<>();
configMap.put(MONGO_USERNAME, "myuser");
configMap.put(MONGO_PASSWORD, "mypassword");
configMap.put(MONGO_PORT, MONGO_PORT_DEFAULT + 1000);
configMap.put(MONGO_HOST, "localhost");
configMap.put(MONGO_DATABASE, "mydb");
configMap.put(COLLECTION_FORMAT, "{$topic}");
configMap.put(TOPICS_CONFIG, "a");
Field credentialsField = MongoWrapper.class.getDeclaredField("credentials");
credentialsField.setAccessible(true);
MongoClientOptions timeout = MongoClientOptions.builder()
.connectTimeout(1)
.socketTimeout(1)
.serverSelectionTimeout(1)
.build();
MongoWrapper wrapper = new MongoWrapper(new AbstractConfig(CONFIG_DEF, configMap), timeout);
assertThat(credentialsField.get(wrapper), is(not(nullValue())));
assertFalse(wrapper.checkConnection());
thrown.expect(MongoException.class);
try {
wrapper.store("mytopic", new Document());
} finally {
wrapper.close();
}
}