MongoDB数据库连接

public class MongoDBFactory {   
    /**私有无参构造**/
    private MongoDBFactory(){ super();}
    /**内部静态私有类**/
    private static final class SingletonHolder {
        private static MongoDBFactory instance = new MongoDBFactory();
    }
    /**获取单例**/
    public static MongoDBFactory me(){
        return SingletonHolder.instance;
    }
    /**连接客户端,线程安全**/
    private MongoClient client;
    /**默认连接库**/
    public final static String DefaultDatabase = Configurator.getString("mongodb_database");

    /**初始化客户端,在适当的时机调用,来达到参数配置**/
    public void initClient(String url) throws Exception{
        try{
            Builder options = new MongoClientOptions.Builder();
            // 连接池设置为300个连接,默认为100
            options.connectionsPerHost(300);
            // 连接超时，推荐>3000毫秒
            options.connectTimeout(15000);
            // 最大等待时间
            options.maxWaitTime(5000); 
            // 套接字超时时间，0无限制
            options.socketTimeout(0);
            // 线程队列数
            options.threadsAllowedToBlockForConnectionMultiplier(5000);
            // 连接URL
            MongoClientURI uri = new MongoClientURI(url, options);  
            // 初始化客户端
            this.client = new MongoClient(uri);
        }catch(Exception e){
            e.printStackTrace();
        }
    }

    public void initClient() throws Exception {
        initClient(Configurator.getString("mongodb_url"));
    }

    /**
     * 判断是否已连接
     */
    public boolean isConnect(){
        return this.client != null;
    }


    public MongoDBConnection openConnection() throws Exception{
        if(this.client == null) throw new Exception("连接不存在.");
        return new MongoDBConnection(this.client);
    }

    public void closeConnection(MongoDBConnection connection){
        if(connection != null){
            connection.close();
        }
    }

    public synchronized void resetMongoClient(String url, Builder options){
        closeMongoClient();
        this.client = new MongoClient(new MongoClientURI(url, options)); 
    }

    public synchronized void closeMongoClient(){
        if(this.client != null){
            this.client.close();
            this.client = null;
        }
    }
}

public class MongoDBConnection {
    private MongoClient mongoClient;

    public MongoDBConnection(MongoClient mongoClient){
        this.mongoClient = mongoClient;
    }

    public MongoClient getMongoClient(){
        return this.mongoClient;
    }

    public MongoDatabase getDatabase(String databaseName){
        if(IHelper.isEmpty(databaseName)) return null;
        return this.mongoClient.getDatabase(databaseName);
    }

    public MongoCollection<Document> getCollection(String databaseName, String collectionName){
        if(IHelper.isEmpty(databaseName)) return null;
        if(IHelper.isEmpty(collectionName)) return null;
        MongoDatabase mdb = this.getDatabase(databaseName);
        if(mdb != null){
            return mdb.getCollection(collectionName);
        }
        return null;
    }

    public List<String> listCollectionNames(String databaseName) {
        List<String> list = new ArrayList<String>();
        if(!IHelper.isEmpty(databaseName)){
            MongoDatabase mdb = this.getDatabase(databaseName);
            if(mdb != null){
                MongoIterable<String> colls = mdb.listCollectionNames();
                 for (String collName : colls) {
                    list.add(collName);
                }
            }
        }
        return list;
    }

    public MongoIterable<String> listDatabaseNames() {
        MongoIterable<String> mi = mongoClient.listDatabaseNames();
        return mi;
    }

    public void dropDatabase(String databaseName) {
        MongoDatabase mdb = this.getDatabase(databaseName);
        if(mdb != null){
            mdb.drop();
        }
    }

    public Document findById(MongoCollection<Document> coll, Object id) {
        Document myDoc = coll.find(Filters.eq("_id", id)).first();
        return myDoc;
    }

    public Document findByObjectId(MongoCollection<Document> coll, String id) {
        ObjectId _idobj = null;
        try {
            _idobj = new ObjectId(id);
        } catch (Exception e) {
            return null;
        }
        Document myDoc = coll.find(Filters.eq("_id", _idobj)).first();
        return myDoc;
    }

    public int getCount(MongoCollection<Document> coll) {
        int count = (int) coll.count();
        return count;
    }

    public MongoCursor<Document> find(MongoCollection<Document> coll, Bson filter) {
        return coll.find(filter).iterator();
    }

    public MongoCursor<Document> findByPage(MongoCollection<Document> coll, Bson filter, int pageNo, int pageSize) {
        Bson orderBy = new BasicDBObject("_id", 1);
        return this.findByPage(coll, orderBy, filter, pageNo, pageSize);
    }

    public MongoCursor<Document> findByPage(MongoCollection<Document> coll, Bson orderBy, Bson filter, int pageNo, int pageSize) {
        return coll.find(filter).sort(orderBy).skip((pageNo - 1) * pageSize).limit(pageSize).iterator();
    }


    public int deleteById(MongoCollection<Document> coll, String id) {
        int count = 0;
        Bson filter = Filters.eq("_id", id);
        DeleteResult deleteResult = coll.deleteOne(filter);
        count = (int) deleteResult.getDeletedCount();
        return count;
    }

    /*
     * 更新方法修改
     * @Author:lkk
     */
    public Document updateById(MongoCollection<Document> coll, String id, Document newdoc) {
        Bson filter = Filters.eq("_id",id);
        coll.updateOne(filter, new Document("$set", newdoc));
        return newdoc;
    }

    public Document replaceById(MongoCollection<Document> coll, String id, Document newdoc) {
        ObjectId _idobj = null;
        try {
            byte[] bytes = id.getBytes();
            int len = bytes.length - 12;
            if(len < 0){
                bytes = ByteHelper.merge(new byte[-len],bytes);
            }
            _idobj = new ObjectId(bytes);
            Bson filter = Filters.eq("_id", _idobj);
            coll.replaceOne(filter, newdoc);
            return newdoc;
        } catch (Exception e) {
            return null;
        }

    }

    /*
     * 新增插入方法
     * @Author:lkk
     */
    public void insertById(MongoCollection<Document> coll, String id, Document newdoc) {
        coll.insertOne(newdoc);
    }
    /*
     * 新增插入方法
     * @Author:lkk
     */
    public void insertById(MongoCollection<Document> coll, Document newdoc) {
        coll.insertOne(newdoc);
    }
    public void dropCollection(String databaseName, String collectionName) {
        MongoCollection<Document> mc = this.getCollection(databaseName, collectionName);
        if(mc != null){
            mc.drop();
        }
    }

    public void close(){
        // nothing to do
    }
}