MongoDB 3 操作方法

 

MongoDB 数据库版本：3.0.6

jar 包：mongo-java-driver-3.1.0.jar   （见附件）。

 

数据源配置：

mongodb.soTimeOut=30000
mongodb.connectionsPerHost=500
mongodb.threadsBlock=30
mongodb.host=10.0.0.11
#mongodb.host=localhost
mongodb.port=27017
mongodb.database=dkpt
mongodb.collectionUrl=dkcollect
mongodb.batchSize=3000
mongodb.pool=100

  

MongodbUtils.java

import com.mongodb.BasicDBObject;
import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoWriteException;
import com.mongodb.ServerAddress;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.result.DeleteResult;
import com.mongodb.client.result.UpdateResult;
import com.techstar.plat.alarm.entity.DeviceWarn;
import com.techstar.plat.model.RealTimeData;

import org.bson.Document;

import java.sql.Timestamp;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;

/**
 * 
 * @ClassName: MongodbUtils.java
 * @description
 * 
 *              <pre>
 *             Mongodb 工具类
 *             封装基础的增删改查业务
 * </pre>
 * @author 
 * @company 
 * @date 2015-8-20
 * @version V1.0
 */
public class MongodbUtils {

	private static Map<String, String> propMap = CommonsTkywConstants.propMap;
	private static final Integer soTimeOut = Integer.parseInt(propMap
			.get("mongodb.soTimeOut"));
	private static final Integer connectionsPerHost = Integer.parseInt(propMap
			.get("mongodb.connectionsPerHost"));
	private static final Integer threadsBlock = Integer.parseInt(propMap
			.get("mongodb.threadsBlock"));
	private String host = propMap.get("mongodb.host");
	private int port = Integer.parseInt(propMap.get("mongodb.port"));
	private ExecutorService executor = Executors.newFixedThreadPool(100);

	private String database = propMap.get("mongodb.database");

	private String collectionUrl = propMap.get("mongodb.collectionUrl");

	/**
	 * 通过 ip,端口号，数据库，连接初始化mongodb实例
	 * 
	 * @param host
	 * @param port
	 * @param database
	 * @param collectionUrl
	 */
	public MongodbUtils(String host, int port, String database,
			String collectionUrl) {
		this.host = host;
		this.port = port;
		this.database = database;
		this.collectionUrl = collectionUrl;
	}

	/**
	 * 默认构造函数，使用配置文件中的参数进行初始化mongodb 实例
	 */
	public MongodbUtils() {
	}

	/**
	 * 通过配置文件和传入的collectionName初始化mongodb实例
	 * 
	 * @param collectionName
	 */
	public MongodbUtils(String collectionName) {
		this.collectionUrl = collectionName;
	}

	/**
	 * 获取mongodb连接实例
	 * 
	 * @return
	 */
	private MongoClient getMongoClient() {
		MongoClient mongoClient = new MongoClient(
				new ServerAddress(host, port), new MongoClientOptions.Builder()
						.socketTimeout(soTimeOut)
						.connectionsPerHost(connectionsPerHost)
						.threadsAllowedToBlockForConnectionMultiplier(
								threadsBlock).socketKeepAlive(true).build());
		return mongoClient;
	}

	/**
	 * 
	 * @return
	 */
	private MongoClient getSingleClient() {
		if (mongoClient == null) {
			mongoClient = new MongoClient(new ServerAddress(host, port),
					new MongoClientOptions.Builder()
							.socketTimeout(soTimeOut)
							.connectionsPerHost(connectionsPerHost)
							.threadsAllowedToBlockForConnectionMultiplier(
									threadsBlock).socketKeepAlive(true).build());
		}

		return mongoClient;
	}

	private static final int batchSize = Integer.parseInt(propMap
			.get("mongodb.batchSize")) * 3;

	// private static final int batchDeleteSize = batchSize * 10;

	/**
	 * 只存入key-value的简单数据，如果key相同不删除
	 * 
	 * @param map
	 */
	public void addMapString(Map<String, String> map) {
		if (map == null || map.size() == 0) {
			return;
		}
		List<Document> docs = new ArrayList<Document>();
		Document doc = new Document();
		for (String key : map.keySet()) {
			doc.put(key, map.get(key));
		}
		docs.add(doc);
		executor.execute(new MongodbTask(getMongoClient(), database,
				collectionUrl, docs));
	}

	/**
	 * 关闭mongodb 连接
	 */
	public void close() {
		if (mongoClient != null) {
			mongoClient.close();
			mongoClient = null;
		}

	}

	/**
	 * 只存入key-value的简单数据，如果key相同不删除
	 * 
	 * @param map
	 */
	public void addMapObject(Map<String, Object> map) {
		if (map == null || map.size() == 0) {
			return;
		}
		Document doc = new Document();
		doc.putAll(map);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		dbCollection.insertOne(doc);
	}

	/**
	 * <pre>
	 * 存入一条复杂键值都是String的数据，如果key相同删除以前的数据，并重新插入新数据
	 * 
	 * 其中Map中一个键固定为“key” 含义是cimId或cimid+量测类型
	 * </pre>
	 * 
	 * @param listMap
	 */
	public void addOrUpdateString(Map<String, String> argMap) {
		if (argMap == null || argMap.keySet() == null
				|| argMap.keySet().size() == 0) {
			return;
		}

		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		Document doc = new Document();
		Object keyV = argMap.get("key");
		if (keyV != null) {
			doc.put("key", keyV);
			try {
				dbCollection.deleteMany(doc);
			} catch (MongoWriteException e) {
			}
		}
		doc.putAll(argMap);
		dbCollection.insertOne(doc);
	}

	/**
	 * <pre>
	 * 存入一条复杂键值都是String的数据，如果key相同删除以前的数据，并重新插入新数据
	 * 
	 * 其中Map中一个键固定为“key” 含义是cimId或cimid+量测类型
	 * </pre>
	 * 
	 * @param listMap
	 * @param deleteKey
	 *            需要根据哪个key删除以前的数据
	 */
	public void addOrUpdateString(Map<String, String> argMap, String deleteKey) {
		if (argMap == null || argMap.keySet() == null
				|| argMap.keySet().size() == 0) {
			return;
		}
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		Document doc = new Document();
		Object keyV = argMap.get(deleteKey);
		if (keyV != null) {
			doc.put(deleteKey, keyV);
			try {
				dbCollection.deleteMany(doc);
			} catch (MongoWriteException e) {

			}
		}

		doc.putAll(argMap);
		dbCollection.insertOne(doc);
	}

	/**
	 * <pre>
	 * 存入复杂对象，如果key相同删除以前的数据，并重新插入新数据
	 * 
	 * 其中Map中一个键固定为“key” 含义是cimId或cimid+量测类型
	 * </pre>
	 * 
	 * @param listMap
	 * @param deleteKey
	 *            需要根据哪个key删除以前的数据
	 */
	public void batchAddOrUpdateString(List<Map<String, String>> listMap,
			String deleteKey) {
		List<Document> docs = new ArrayList<Document>();
		int size = listMap.size();
		int index = 0;
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		List<String> deleteList = new LinkedList<String>();
		for (Map<String, String> map : listMap) {
			Document doc = new Document();
			doc.putAll(map);
			index++;
			docs.add(doc);
			deleteList.add(map.get(deleteKey));
			if ((index != 0 && index % batchSize == 0) || index == size) {
				executor.execute(new MongodbTask(getMongoClient(), database,
						collectionUrl, docs, deleteList));
				docs = new ArrayList<Document>();
				deleteList = new LinkedList<String>();
			}
		}
	}

	/**
	 * <pre>
	 * 存入复杂对象，如果key相同删除以前的数据，并重新插入新数据
	 * 
	 * 其中Map中一个键固定为“key” 含义是cimId或cimid+量测类型
	 * </pre>
	 * 
	 * @param listMap
	 */
	public void batchAddOrUpdateString(List<Map<String, String>> listMap) {
		// long start = System.currentTimeMillis();
		// sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss:SSS");
		// System.out.println("sssssssss:" + sdf.format(new Date()));
		List<Document> docs = new LinkedList<Document>();
		int size = listMap.size();
		int index = 0;
		List<String> deleteList = new LinkedList<String>();

		index = 0;
		for (Map<String, String> map : listMap) {
			Document doc = new Document();
			doc.putAll(map);
			index++;
			docs.add(doc);
			deleteList.add(map.get("key"));
			if ((index != 0 && index % batchSize == 0) || index == size) {
				executor.execute(new MongodbTask(getMongoClient(), database,
						collectionUrl, docs, deleteList));
				docs = new ArrayList<Document>();
				deleteList = new LinkedList<String>();
			}
		}
		// mongoClient.close();
	}

	/**
	 * <pre>
	 * 存入复杂对象，如果key相同删除以前的数据，并重新插入新数据,
	 * 
	 * 其中Map中一个键固定为“key” 含义是cimId或cimid+量测类型
	 * </pre>
	 * 
	 * @param listMap
	 */
	public void batchAddOrUpdateObject(List<Map<String, Object>> listMap) {
		List<Document> docs = new ArrayList<Document>();
		int size = listMap.size();
		int index = 0;
		// mongoClient = getSingleClient();
		// mongodb = mongoClient.getDatabase(database);
		// dbCollection = mongodb.getCollection(collectionUrl);

		// Document deleteDoc = new Document();
		List<String> deleteList = new LinkedList<String>();

		// for (Map<String, Object> map : listMap) {
		// deleteList.add((String) map.get("key"));
		// index++;
		// if ((index != 0 && index % batchDeleteSize == 0) || index == size) {
		// deleteDoc = new Document();
		// deleteDoc.put("key", new Document("$in", deleteList));
		// dbCollection.deleteMany(deleteDoc);
		// deleteList = new LinkedList<String>();
		// }
		// }

		for (Map<String, Object> map : listMap) {
			Document doc = new Document();
			doc.putAll(map);
			index++;
			docs.add(doc);
			deleteList.add((String) map.get("key"));
			if ((index != 0 && index % batchSize == 0) || index == size) {
				executor.execute(new MongodbTask(getMongoClient(), database,
						collectionUrl, docs, deleteList, "key"));
				docs = new ArrayList<Document>();
				deleteList = new LinkedList<String>();
			}
		}
		// mongoClient.close();
	}

	/**
	 * <pre>
	 * 存入复杂对象，如果key相同删除以前的数据，并重新插入新数据,
	 * 
	 * 其中Map中一个键固定为“key” 含义是cimId或cimid+量测类型
	 * </pre>
	 * 
	 * @param listMap
	 * @param deleteKey
	 *            需要根据哪个key删除以前的数据
	 */
	public void addOrUpdateObject(Map<String, Object> argMap, String deleteKey) {
		List<Document> docs = new ArrayList<Document>();
		if (argMap == null || argMap.keySet() == null
				|| argMap.keySet().size() == 0) {
			return;
		}
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);

		Document doc = new Document();
		Object keyV = argMap.get(deleteKey);
		if (keyV != null) {
			doc.put(deleteKey, keyV);
			try {
				dbCollection.deleteMany(doc);
			} catch (MongoWriteException e) {

			}
		}
		doc.putAll(argMap);
		executor.execute(new MongodbTask(getMongoClient(), database,
				collectionUrl, docs));

	}

	/**
	 * <pre>
	 * 存入复杂对象，如果key相同删除以前的数据，并重新插入新数据,
	 * 
	 * 其中Map中一个键固定为“key” 含义是cimId或cimid+量测类型
	 * </pre>
	 * 
	 * @param listMap
	 * @param deleteKey
	 *            需要根据哪个key删除以前的数据
	 */
	public void batchAddOrUpdateObject(List<Map<String, Object>> listMap,
			String deleteKey) {
		List<Document> docs = new ArrayList<Document>();
		int size = listMap.size();
		int index = 0;
		// MongoClient mongoClient = getSingleClient();
		// MongoDatabase mongodb = mongoClient.getDatabase(database);
		// MongoCollection<Document> dbCollection =
		// mongodb.getCollection(collectionUrl);

		// Document deleteDoc = new Document();
		List<String> deleteList = new LinkedList<String>();

		// for (Map<String, Object> map : listMap) {
		// deleteList.add((String) map.get(deleteKey));
		// index++;
		// if ((index != 0 && index % batchDeleteSize == 0) || index == size) {
		// deleteDoc = new Document();
		// deleteDoc.put("key", new Document("$in", deleteList));
		// dbCollection.deleteMany(deleteDoc);
		// deleteList = new LinkedList<String>();
		// }
		// }

		for (Map<String, Object> map : listMap) {
			Document doc = new Document();
			doc.putAll(map);
			index++;
			docs.add(doc);
			deleteList.add((String) map.get(deleteKey));
			if ((index != 0 && index % batchSize == 0) || index == size) {
				executor.execute(new MongodbTask(getMongoClient(), database,
						collectionUrl, docs, deleteList, deleteKey));
				docs = new ArrayList<Document>();
				deleteList = new LinkedList<String>();
			}
		}

	}

	/**
	 * <pre>
	 * 存入复杂对象，如果key相同删除以前的数据，并重新插入新数据,
	 * 
	 * 其中Map中一个键固定为“key” 含义是cimId或cimid+量测类型
	 * </pre>
	 * 
	 * @param listMap
	 * @param deleteKey
	 *            需要根据哪个key删除以前的数据
	 */
	public void addOrUpdateObject(Map<String, Object> argMap) {
		List<Document> docs = new ArrayList<Document>();
		if (argMap == null || argMap.keySet() == null
				|| argMap.keySet().size() == 0) {
			return;
		}
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		Document doc = new Document();
		Object keyV = argMap.get("key");
		if (keyV != null) {
			doc.put("key", keyV);
			try {
				dbCollection.deleteMany(doc);
			} catch (MongoWriteException e) {

			}
		}
		for (String key : argMap.keySet()) {
			doc.put(key, argMap.get(key));
		}
		docs.add(doc);
		executor.execute(new MongodbTask(getMongoClient(), database,
				collectionUrl, docs));
	}

	/**
	 * 批量存入复杂对象，如果key相同不删除
	 * 
	 * @param listMap
	 */
	public void batchAddMapString(List<Map<String, String>> listMap) {

		List<Document> docs = new ArrayList<Document>();
		int size = listMap.size();
		int index = 0;
		for (Map<String, String> map : listMap) {
			Document doc = new Document();
			for (String key : map.keySet()) {
				doc.put(key, map.get(key));
			}
			index++;
			docs.add(doc);
			if ((index != 0 && index % batchSize == 0) || index == size) {
				executor.execute(new MongodbTask(getMongoClient(), database,
						collectionUrl, docs));
				docs = new ArrayList<Document>();
			}
		}
	}

	/**
	 * 批量存入复杂对象，如果key相同不删除
	 * 
	 * @param listMap
	 */
	public void batchAddObject(List<Map<String, Object>> listMap) {
		List<Document> docs = new ArrayList<Document>();
		int size = listMap.size();
		int index = 0;
		for (Map<String, Object> map : listMap) {
			Document doc = new Document();
			for (String key : map.keySet()) {
				doc.put(key, map.get(key));
			}
			index++;
			docs.add(doc);
			if ((index != 0 && index % batchSize == 0) || index == size) {
				executor.execute(new MongodbTask(getMongoClient(), database,
						collectionUrl, docs));
				docs = new ArrayList<Document>();
			}
		}
	}

	/**
	 * 根据key获取值 供实时数据使用
	 * 
	 * 如果key是cimeId+量测类型：则返回值该量测类型的值
	 * 
	 * 量测类型含义：
	 * 
	 * <pre>
	 * P： 有功 
	 * Q ：无功 
	 * U ：电压 
	 * I： 电流
	 * S：开关、刀闸开合状态
	 * </pre>
	 * 
	 * @param key
	 * @return
	 */
	public String findByCimeIdType(String key) {
		Document doc = new Document();
		doc.append("key", key);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		FindIterable<Document> finds = dbCollection.find(doc);
		MongoCursor<Document> cursor = finds.iterator();
		try {
			if (cursor.hasNext()) {
				Document findDoc = cursor.next();
				String value = (String) findDoc.get("value");
				return value;
			}
		} finally {
			if (cursor != null) {
				cursor.close();
				cursor = null;
			}

		}

		return null;
	}

	/**
	 * <pre>
	 * 根据key获取值,如果有值则获取长度为2的数组，
	 * 其中array[0]是具体值，array[1]返回是否有效，0-无效，1-有效
	 * 如果查询不到值则返回为空
	 * 
	 * 如果key是cimeId+量测类型：则返回值该量测类型的值
	 * 
	 * 量测类型含义：
	 * 
	 * 
	 * P： 有功 
	 * Q ：无功 
	 * U ：电压 
	 * I： 电流
	 * S：开关、刀闸开合状态
	 * </pre>
	 * 
	 * @param key
	 * @return
	 */
	public String[] findValueValidByCimeIdType(String key) {
		Document doc = new Document();
		doc.append("key", key);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		FindIterable<Document> finds = dbCollection.find(doc);
		MongoCursor<Document> cursor = finds.iterator();
		try {
			if (cursor.hasNext()) {
				Document findDoc = cursor.next();
				String[] values = new String[2];
				String value = (String) findDoc.get("value");
				values[0] = value;
				Object validO = (Object) findDoc.get("valid");
				if (validO != null) {
					String valid = (String) validO;
					values[1] = valid;
				}
				return values;
			}
		} finally {
			if (cursor != null) {
				cursor.close();
				cursor = null;
			}

		}

		return null;
	}

	public MongoCollection<Document> getCollection() {
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		return dbCollection;
	}

	/**
	 * <pre>
	 * 根据key获取值,如果无效返回0000
	 * 
	 * 如果key是cimeId+量测类型：则返回值该量测类型的值
	 * 
	 * 量测类型含义：
	 * 
	 * P： 有功 
	 * Q ：无功 
	 * U ：电压 
	 * I： 电流
	 * S：开关、刀闸开合状态
	 * </pre>
	 * 
	 * @param key
	 * @return
	 */
	public String findValueByCimeIdType(String key) {
		Document doc = new Document();
		doc.append("key", key);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		FindIterable<Document> finds = dbCollection.find(doc);
		MongoCursor<Document> cursor = finds.iterator();
		try {
			if (cursor.hasNext()) {
				Document findDoc = cursor.next();
				String value = (String) findDoc.get("value");
				Object validO = (Object) findDoc.get("valid");
				if (validO != null) {
					String valid = (String) validO;
					if (valid.equals("0")) {
						return "0000";
					}
				}
				return value;
			}
		} finally {
			if (cursor != null) {
				cursor.close();
				cursor = null;
			}
		}

		return null;
	}

	/**
	 * 删除集合数据
	 */
	public void drop() {
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		dbCollection.drop();
	}

	private static SimpleDateFormat sdf = new SimpleDateFormat(
			"yyyy-MM-dd HH:mm:ss");

	/**
	 * 根据key活动告警对象
	 * 
	 * @param key
	 * @return
	 */
	public DeviceWarn getWarn(String key) {
		Document doc = new Document();
		doc.append("key", key);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		FindIterable<Document> finds = dbCollection.find(doc);
		MongoCursor<Document> cursor = finds.iterator();
		try {
			if (cursor.hasNext()) {
				Document findDoc = cursor.next();
				String value = String.valueOf(findDoc.get("value"));
				DeviceWarn warn = new DeviceWarn();
				String methodid = (String) findDoc.get("methodid");
				warn.setModelId(methodid);
				String name = (String) findDoc.get("name");
				warn.setName(name);
				warn.setCimId(key);

				Object timeO = findDoc.get("time");
				if (timeO != null) {
					String time = (String) timeO;
					warn.setValue(Double.parseDouble(value));

					try {
						warn.setAlarmDate(new Timestamp(sdf.parse(time)
								.getTime()));
					} catch (ParseException e) {
					}
				}
				return warn;
			}
		} finally {
			if (cursor != null) {
				cursor.close();
				cursor = null;
			}

		}

		return null;
	}

	/**
	 * 根据cime+量测类型查询当前值及其对应时间，
	 * 
	 * @param key
	 * @return
	 */
	public RealTimeData findByCimeIdType4Alarm(String key) {
		Document doc = new Document();
		doc.append("key", key);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		FindIterable<Document> finds = dbCollection.find(doc);
		MongoCursor<Document> cursor = finds.iterator();
		try {
			if (cursor.hasNext()) {
				Document findDoc = cursor.next();
				String value = String.valueOf(findDoc.get("value"));
				RealTimeData realTimeData = new RealTimeData();

				Object timeO = findDoc.get("time");
				if (timeO != null) {
					String time = (String) timeO;
					realTimeData.setValue(Double.parseDouble(value));
					SimpleDateFormat sdf = new SimpleDateFormat(
							"yyyy-MM-dd HH:mm:ss");
					try {
						realTimeData.setTime(new Timestamp(sdf.parse(time)
								.getTime()));
					} catch (ParseException e) {
					}
				}
				return realTimeData;
			}
		} finally {
			if (cursor != null) {
				cursor.close();
				cursor = null;
			}
		}

		return null;
	}

	// /**
	// * 根据cimeID获取设备对象相关信息
	// *
	// * 数据长度是2：obj[0]是类型，obj[1]是一体化模型对象
	// *
	// * 如：obj[0]是AcLineDot,obj[1]一定时AcLineDotPO对象，对用用可以对obj[1]强制转换成AcLineDotPO
	// *
	// * @param key
	// * cime id
	// * @return
	// */
	// public Object[] findByCimeId(String key) {
	// Document doc = new Document();
	// doc.append("key", key);
	// FindIterable<Document> finds = dbCollection.find(doc);
	// MongoCursor<Document> cursor = finds.iterator();
	// if (cursor.hasNext()) {
	// Document findDoc = cursor.next();
	// String type = (String) findDoc.get("type");
	// Object obj = findDoc.get("obj");
	// Object[] objs = new Object[2];
	// objs[0] = type;
	// objs[1] = obj;
	// return objs;
	// }
	// return null;
	// }

	/**
	 * 根据条件查找数据
	 * 
	 * @param findArgs
	 * @return
	 */
	public List<Document> find(Map<String, Object> findArgs) {
		Document doc = new Document();
		for (String key : findArgs.keySet()) {
			doc.append(key, findArgs.get(key));
		}
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		FindIterable<Document> finds = dbCollection.find(doc);
		List<Document> docs = new ArrayList<Document>();
		MongoCursor<Document> cursor = finds.iterator();
		try {
			while (cursor.hasNext()) {
				Document findDoc = cursor.next();
				docs.add(findDoc);
			}
		} finally {
			if (cursor != null) {
				cursor.close();
				cursor = null;
			}
		}

		return docs.size() > 0 ? docs : null;
	}

	/**
	 * <pre>
	 * 根据key在历史表比较最近的2个版本数据值是否相同，
	 * 如果相同返回null,
	 * 如果不相同返回key
	 * </pre>
	 * 
	 * @param key
	 * @return
	 */
	public String compareWithLastValue(String key) {
		Document doc = new Document();
		doc.append("key", key);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		FindIterable<Document> finds = dbCollection.find(doc).limit(2)
				.sort(new BasicDBObject("time", -1));
		MongoCursor<Document> cursor = finds.iterator();
		String currentValue = null;// 获取当前值
		String lastTimeValue = null;// 获取上次值
		try {
			if (cursor.hasNext()) {
				Document findDoc = cursor.next();
				currentValue = (String) findDoc.get("value");
			}

			if (cursor.hasNext()) {
				Document findDoc = cursor.next();
				lastTimeValue = (String) findDoc.get("value");
			}

			if (currentValue != null && !currentValue.trim().equals("")) {
				if (lastTimeValue != null && !lastTimeValue.trim().equals("")) {
					if (currentValue.equals(lastTimeValue)) {
						return null;
					} else {
						return key;
					}
				}
			}
		} finally {
			if (cursor != null) {
				cursor.close();
				cursor = null;
			}
		}

		return null;
	}

	/**
	 * 根据key获取最新一条数据
	 * 
	 * @param key
	 * @return
	 */
	public String findLastValue(String key) {
		Document doc = new Document();
		doc.append("key", key);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		FindIterable<Document> finds = dbCollection.find(doc);
		MongoCursor<Document> cursor = finds.iterator();
		try {
			if (cursor.hasNext()) {
				Document findDoc = cursor.next();
				String value = (String) findDoc.get("value");
				return value;
			}
		} finally {
			if (cursor != null) {
				cursor.close();
				cursor = null;
			}

		}

		return null;
	}

	/**
	 * 更新对象
	 * 
	 * @param filter
	 * @param update
	 * @return
	 */
	public long update(Map<String, Object> filter, Map<String, Object> update) {
		Document doc = new Document();
		for (String key : filter.keySet()) {
			doc.append(key, filter.get(key));
		}
		BasicDBObject updateDocument = new BasicDBObject();
		BasicDBObject newDocument = new BasicDBObject();
		for (String key : update.keySet()) {
			newDocument.append(key, update.get(key));
		}
		updateDocument.append("$set", newDocument);
		mongoClient = getSingleClient();
		mongodb = mongoClient.getDatabase(database);
		dbCollection = mongodb.getCollection(collectionUrl);
		UpdateResult result = dbCollection.updateMany(doc, updateDocument);
		long size = result.getMatchedCount();
		return size;
	}

	private MongoClient mongoClient = null;
	private MongoDatabase mongodb = null;
	private MongoCollection<Document> dbCollection = null;

	/**
	 * 删除对象
	 * 
	 * @param deleteArgs
	 * @return
	 */
	public long delete(Map<String, Object> deleteArgs) {
		Document doc = new Document();
		for (String key : deleteArgs.keySet()) {
			doc.put(key, deleteArgs.get(key));
		}
		DeleteResult result = null;

		try {
			mongoClient = getSingleClient();
			mongodb = mongoClient.getDatabase(database);
			dbCollection = mongodb.getCollection(collectionUrl);
			result = dbCollection.deleteMany(doc);
			long size = result.getDeletedCount();
			return size;
		} catch (MongoWriteException e) {

		}
		return 0;
	}
}