JAVA单例MongoDB工具类详解编程语言

JAVA驱动版本：

       <!-- MongoDB驱动 --> 
        <dependency> 
            <groupId>org.mongodb</groupId> 
            <artifactId>mongo-java-driver</artifactId> 
            <version>3.0.2</version> 
        </dependency> 
 

工具类代码如下：

package utils; 
import java.util.ArrayList; 
import java.util.List; 
import org.apache.commons.configuration.CompositeConfiguration; 
import org.apache.commons.configuration.ConfigurationException; 
import org.apache.commons.configuration.PropertiesConfiguration; 
import org.bson.Document; 
import org.bson.conversions.Bson; 
import org.bson.types.ObjectId; 
import com.mongodb.BasicDBObject; 
import com.mongodb.MongoClient; 
import com.mongodb.MongoClientOptions; 
import com.mongodb.MongoClientOptions.Builder; 
import com.mongodb.WriteConcern; 
import com.mongodb.client.MongoCollection; 
import com.mongodb.client.MongoCursor; 
import com.mongodb.client.MongoDatabase; 
import com.mongodb.client.MongoIterable; 
import com.mongodb.client.model.Filters; 
import com.mongodb.client.result.DeleteResult; 
/** 
* MongoDB工具类 Mongo实例代表了一个数据库连接池，即使在多线程的环境中，一个Mongo实例对我们来说已经足够了<br> 
* 注意Mongo已经实现了连接池，并且是线程安全的。 <br> 
* 设计为单例模式， 因 MongoDB的Java驱动是线程安全的，对于一般的应用，只要一个Mongo实例即可，<br> 
* Mongo有个内置的连接池（默认为10个） 对于有大量写和读的环境中，为了确保在一个Session中使用同一个DB时，<br> 
* DB和DBCollection是绝对线程安全的<br> 
*  
* @author zhoulingfei 
* @date 2015-5-29 上午11:49:49 
* @version 0.0.0 
* @Copyright (c)1997-2015 NavInfo Co.Ltd. All Rights Reserved. 
*/ 
public enum MongoDBUtil { 
/** 
* 定义一个枚举的元素，它代表此类的一个实例 
*/ 
instance; 
private MongoClient mongoClient; 
static { 
System.out.println("===============MongoDBUtil初始化========================"); 
CompositeConfiguration config = new CompositeConfiguration(); 
try { 
config.addConfiguration(new PropertiesConfiguration("mongodb.properties")); 
} catch (ConfigurationException e) { 
e.printStackTrace(); 
} 
// 从配置文件中获取属性值 
String ip = config.getString("host"); 
int port = config.getInt("port"); 
instance.mongoClient = new MongoClient(ip, port); 
// or, to connect to a replica set, with auto-discovery of the primary, supply a seed list of members 
// List<ServerAddress> listHost = Arrays.asList(new ServerAddress("localhost", 27017),new ServerAddress("localhost", 27018)); 
// instance.mongoClient = new MongoClient(listHost); 
// 大部分用户使用mongodb都在安全内网下，但如果将mongodb设为安全验证模式，就需要在客户端提供用户名和密码： 
// boolean auth = db.authenticate(myUserName, myPassword); 
Builder options = new MongoClientOptions.Builder(); 
// options.autoConnectRetry(true);// 自动重连true 
// options.maxAutoConnectRetryTime(10); // the maximum auto connect retry time 
options.connectionsPerHost(300);// 连接池设置为300个连接,默认为100 
options.connectTimeout(15000);// 连接超时，推荐>3000毫秒 
options.maxWaitTime(5000); // 
options.socketTimeout(0);// 套接字超时时间，0无限制 
options.threadsAllowedToBlockForConnectionMultiplier(5000);// 线程队列数，如果连接线程排满了队列就会抛出“Out of semaphores to get db”错误。 
options.writeConcern(WriteConcern.SAFE);// 
options.build(); 
} 
// ------------------------------------共用方法--------------------------------------------------- 
/** 
* 获取DB实例 - 指定DB 
*  
* @param dbName 
* @return 
*/ 
public MongoDatabase getDB(String dbName) { 
if (dbName != null && !"".equals(dbName)) { 
MongoDatabase database = mongoClient.getDatabase(dbName); 
return database; 
} 
return null; 
} 
/** 
* 获取collection对象 - 指定Collection 
*  
* @param collName 
* @return 
*/ 
public MongoCollection<Document> getCollection(String dbName, String collName) { 
if (null == collName || "".equals(collName)) { 
return null; 
} 
if (null == dbName || "".equals(dbName)) { 
return null; 
} 
MongoCollection<Document> collection = mongoClient.getDatabase(dbName).getCollection(collName); 
return collection; 
} 
/** 
* 查询DB下的所有表名 
*/ 
public List<String> getAllCollections(String dbName) { 
MongoIterable<String> colls = getDB(dbName).listCollectionNames(); 
List<String> _list = new ArrayList<String>(); 
for (String s : colls) { 
_list.add(s); 
} 
return _list; 
} 
/** 
* 获取所有数据库名称列表 
*  
* @return 
*/ 
public MongoIterable<String> getAllDBNames() { 
MongoIterable<String> s = mongoClient.listDatabaseNames(); 
return s; 
} 
/** 
* 删除一个数据库 
*/ 
public void dropDB(String dbName) { 
getDB(dbName).drop(); 
} 
/** 
* 查找对象 - 根据主键_id 
*  
* @param collection 
* @param id 
* @return 
*/ 
public Document findById(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 coll.find(filter).sort(orderBy).skip((pageNo - 1) * pageSize).limit(pageSize).iterator(); 
} 
/** 
* 通过ID删除 
*  
* @param coll 
* @param id 
* @return 
*/ 
public int deleteById(MongoCollection<Document> coll, String id) { 
int count = 0; 
ObjectId _id = null; 
try { 
_id = new ObjectId(id); 
} catch (Exception e) { 
return 0; 
} 
Bson filter = Filters.eq("_id", _id); 
DeleteResult deleteResult = coll.deleteOne(filter); 
count = (int) deleteResult.getDeletedCount(); 
return count; 
} 
/** 
* FIXME 
*  
* @param coll 
* @param id 
* @param newdoc 
* @return 
*/ 
public Document updateById(MongoCollection<Document> coll, String id, Document newdoc) { 
ObjectId _idobj = null; 
try { 
_idobj = new ObjectId(id); 
} catch (Exception e) { 
return null; 
} 
Bson filter = Filters.eq("_id", _idobj); 
// coll.replaceOne(filter, newdoc); // 完全替代 
coll.updateOne(filter, new Document("$set", newdoc)); 
return newdoc; 
} 
public void dropCollection(String dbName, String collName) { 
getDB(dbName).getCollection(collName).drop(); 
} 
/** 
* 关闭Mongodb 
*/ 
public void close() { 
if (mongoClient != null) { 
mongoClient.close(); 
mongoClient = null; 
} 
} 
/** 
* 测试入口 
*  
* @param args 
*/ 
public static void main(String[] args) { 
String dbName = "GC_MAP_DISPLAY_DB"; 
String collName = "COMMUNITY_BJ"; 
MongoCollection<Document> coll = MongoDBUtil.instance.getCollection(dbName, collName); 
// 插入多条 
// for (int i = 1; i <= 4; i++) { 
// Document doc = new Document(); 
// doc.put("name", "zhoulf"); 
// doc.put("school", "NEFU" + i); 
// Document interests = new Document(); 
// interests.put("game", "game" + i); 
// interests.put("ball", "ball" + i); 
// doc.put("interests", interests); 
// coll.insertOne(doc); 
// } 
// // 根据ID查询 
// String id = "556925f34711371df0ddfd4b"; 
// Document doc = MongoDBUtil2.instance.findById(coll, id); 
// System.out.println(doc); 
// 查询多个 
// MongoCursor<Document> cursor1 = coll.find(Filters.eq("name", "zhoulf")).iterator(); 
// while (cursor1.hasNext()) { 
// org.bson.Document _doc = (Document) cursor1.next(); 
// System.out.println(_doc.toString()); 
// } 
// cursor1.close(); 
// 查询多个 
// MongoCursor<Person> cursor2 = coll.find(Person.class).iterator(); 
// 删除数据库 
// MongoDBUtil2.instance.dropDB("testdb"); 
// 删除表 
// MongoDBUtil2.instance.dropCollection(dbName, collName); 
// 修改数据 
// String id = "556949504711371c60601b5a"; 
// Document newdoc = new Document(); 
// newdoc.put("name", "时候"); 
// MongoDBUtil.instance.updateById(coll, id, newdoc); 
// 统计表 
// System.out.println(MongoDBUtil.instance.getCount(coll)); 
// 查询所有 
Bson filter = Filters.eq("count", 0); 
MongoDBUtil.instance.find(coll, filter); 
} 
}