mongodb集群的数据库连接池

程序中使用到的mongodb数据库连接池

package com.common.db;

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoException;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import org.bson.Document;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.io.IOException;
import java.io.InputStream;
import java.util.Properties;

public class MongoPoolManager {

/**
初始化：静态字段
*/
  private static final Logger LOGGER = LoggerFactory.getLogger(MongoPoolManager.class);
  private static String sIP = null;
  private static int iPort = 0;
  private static String dbName = null;
  private static String dbCollection = null;
  private static int connectionsPerHost = 20;
  private static int threadsAllowedToBlock = 20;
  private static int maxWaitTime = 1000 * 60 * 2; //1000*60*2 
  private static int connectTimeout = 1000 * 60 * 1;//1000*60*1;


//请在内部类，跟随外部类一起加载：初始化
  public static class Holder {
    //获取属性文件
    private static Properties properties;

    static {
      try {
        properties = loadPropertyFile("mongoConfig.properties");
        sIP = (String) properties.get("ip");
        System.out.println(properties.get("port"));
        iPort = Integer.parseInt((String) properties.get("port"));
        dbName = (String) properties.get("dbName");
        dbCollection = (String) properties.get("dbCollection");
        connectionsPerHost = Integer.parseInt((String) properties.get("connectionsPerHost"));
        threadsAllowedToBlock = Integer.parseInt((String) properties.get("threadsAllowedToBlock"));
        maxWaitTime = Integer.parseInt((String) properties.get("maxWaitTime"));
        connectTimeout = Integer.parseInt((String) properties.get("connectTimeout"));
        LOGGER.info("Data source had finished initialization.");
      } catch (Exception e) {
        e.printStackTrace();
      }
    }
  }

  //MongoClient的实例代表数据库连接池，是线程安全的，可以被多线程共享，客户端在多线程条件下仅维持一个实例即可
  private static MongoClient mongoClient = null;

  private MongoPoolManager() {//私有的构造函数
    Holder.properties.forEach((k, v) -> {
      System.out.println(k + ":" + v);
    });
    if (mongoClient == null) {
      MongoClientOptions.Builder build = new MongoClientOptions.Builder();
      build.connectionsPerHost(connectionsPerHost);   //与目标数据库能够建立的最大connection数量为50
//            build.autoConnectRetry(true);   //自动重连数据库启动
      build.threadsAllowedToBlockForConnectionMultiplier(threadsAllowedToBlock); //如果当前所有的connection都在使用中，则每个connection上可以有50个线程排队等待
      build.maxWaitTime(maxWaitTime);
      build.connectTimeout(connectTimeout);    //与数据库建立连接的timeout设置为n分钟
      MongoClientOptions myOptions = build.build();
      try {
        mongoClient = new MongoClient(sIP, myOptions);   //数据库连接实例
      } catch (MongoException e) {
        e.printStackTrace();
      }

    }
  }

  /********单例模式声明开始，采用饿汉式方式生成，保证线程安全********************/
  //类初始化时，自行实例化，饿汉式单例模式
  private static final MongoPoolManager mongoDBDaoImpl = new MongoPoolManager();

  //单例的静态工厂方法
  public static MongoPoolManager getMongoDBDaoImplInstance() {
    return mongoDBDaoImpl;
  }

  /*
   * 使用连接池，创建数据连接
   */
  public static MongoCollection<Document> getMongoConnection() {
    MongoDatabase database = null;
    MongoCollection<Document> collection = null;
    database = mongoClient.getDatabase(dbName); //获取数据库实例
    collection = database.getCollection(dbCollection);    //获取数据库中指定的collection集合
    return collection;
  }
  
  /*
   * 读取属性文件：读取本次资源文件【打包在resources】
   * 返回properties对象
   */
  private static Properties loadPropertyFile(String fullFile) throws IOException {
    Properties p = new Properties();
    if (fullFile == null || "".equals(fullFile)) {
      LOGGER.error("File path is null.");
      System.exit(1);
    } else {
      //加载属性文件
      InputStream inStream = DBPoolConnection.class.getClassLoader().getResourceAsStream(fullFile);
      p.load(inStream);
    }
    return p;
  }

    public static void main(String[] args) {
//		MongoCollection<Document> mongoConnection_ = mongoDBDaoImpl.getMongoConnection();
		MongoCollection<Document> mongoConnection = MongoPoolManager.getMongoConnection();
		if (mongoConnection != null) {
//			System.out.println(mongoConnection.setCount());
			FindIterable<Document> findIterable = mongoConnection.find();
			MongoCursor<Document> mongoCursor = findIterable.iterator();  
	        while(mongoCursor.hasNext()){  
	            System.out.println(mongoCursor.next());
	         }  
			LOGGER.info("note:Mongodb 连接成功！！");
		}else {
			LOGGER.error("note:Mongodb 连接失败！！");
		}
	}
}

其中使用的资源文件mongoConfig.properties：

##mongodb connection IP
ip=192.168.xxx.xx
port=27017
dbName=xxxxx
dbCollection=xxxx

### mongodb connetion pool config  
connectionsPerHost=20
threadsAllowedToBlock=20
##1000*60*2ms 
maxWaitTime=120000
##1000*60*1ms
connectTimeout=60000