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;
}
}
相关推荐
NoSQL是一项全新的数据库革命性运动，虽然它的历史可以追溯到1998年，但是NoSQL真正深⼊⼼并得到⼴泛的应⽤是在进⼊⼤数据时候以后，业界普遍认为NoSQL是更适合大数据存储的技术方案，这才使得NoSQL的发展达到了...
MongoDB 是一种流行的开源NoSQL数据库系统，以其灵活性、可扩展性和高性能而受到广泛应用。它采用了文档型数据模型，以BSON（Binary JSON）...了解和熟练掌握MongoDB的操作方法，对于开发人员来说是非常有价值的技能。
它是MongoDB操作的抽象层，封装了大量的CRUD（创建、读取、更新、删除）操作，以及更复杂的查询和聚合功能。在`App.java`中，你可以看到如何初始化和使用`MongoDBTemplate`。通常，你需要通过`ApplicationContext`...
### MongoDB的安装与操作方法及规则 #### 一、NoSQL数据库分类及其特点 NoSQL数据库因其非关系型的数据存储方式，在处理大规模数据时具备很高的灵活性和可扩展性。主要分为四大类： 1. **键值(Key-Value)存储...
在进行任何MongoDB操作之前，首先需要确保已经正确安装并启动了MongoDB服务。接着，开发者需要通过合适的客户端工具或者编程语言提供的驱动程序来建立与MongoDB服务器的连接。连接成功后，才能执行后续的数据库操作...
- **启动MongoDB**：通过上述方法启动MongoDB，并密切关注日志文件（如`tail -100f /home/mongodb/mongodb.log`），以便及时发现并解决任何问题。 - **正确关闭MongoDB**：切记不要使用`kill -9`强行终止MongoDB进程...
对于批量删除集合的操作，虽然Java驱动没有提供直接方法，但可以通过执行JavaScript脚本来实现。这通常涉及网络通讯开销，因此在处理大量集合时需谨慎。 MongoDB 的安装相对简单，提供多种平台的下载，并有多种编程...
### MongoDB数据库基本操作详解 #### 一、连接MongoDB数据库 MongoDB是一个广泛使用的开源文档数据库，支持多种编程语言。为了能够与MongoDB交互并执行各种数据库操作，首先需要通过官方提供的驱动程序或其他第三...
### MongoDB相关操作知识点 #### 一、环境搭建与配置 **知识点1：Git安装与配置** 在进行MongoDB的相关操作之前，首先需要确保系统中已安装Git。如果未安装，可以按照以下步骤进行： 1. **卸载原有Git**： - ...
3. **数据库操作** - 创建数据库：使用`use`命令创建或切换到一个数据库。 - 查看所有数据库：运行`show dbs`命令。 - 删除数据库：使用`dropDatabase()`函数。 4. **集合操作** - 集合是MongoDB中的数据结构，...
Spring Boot 集成 MongoDB 的操作方法 随着大数据时代的来临，非关系型数据库的需求日益增加，而 MongoDB 作为最早热门非关系数据库之一，使用也比较普遍。下面就 Spring Boot 集成 MongoDB 的操作方法进行详细的...
例如，使用`MongoClients.create()`方法建立连接，`MongoDatabase`和`MongoCollection`接口分别代表数据库和集合，通过它们可以执行查询、插入、更新和删除操作。 MongoDB的Shell是一个基于JavaScript的命令行工具...
本资料将深入讲解如何使用Java实现对MongoDB数据库的操作。 一、MongoDB简介 MongoDB是一个基于分布式文件存储的NoSQL数据库，它摒弃了传统的关系型数据库模型，采用JSON（JavaScript Object Notation）格式的文档...
本文将深入探讨如何使用Java API连接MongoDB，并执行基本的操作。 首先，确保已经在项目中引入了MongoDB的Java驱动程序。如果使用Maven，可以在`pom.xml`文件中添加以下依赖： ```xml <groupId>org.mongodb ...
这部分涉及MongoDB的数据中心感知功能，包括如何在MongoDB操作和部署中实现运营上的隔离，管理分片标签，以及如何部署地理分布式副本集。这些功能对于多数据中心的场景尤为重要，有助于优化数据读写性能和确保数据的...
在本示例中，"数据库mongodb操作辅助类" 提供了一种方便的方式来与MongoDB进行交互，尤其是针对集合（collections）和文件的管理。这个辅助类（helper class）可能包含了诸如插入、查询、更新和删除数据等基本操作，...
了解save()与insert()在数据插入上的区别，熟悉update()方法在数据更新上的应用，以及会用drop()和remove()进行数据的删除，再结合find()和find_one()方法进行高效的数据查询和字段筛选，是进行MongoDB操作的基础。...
3. **操作集合** 数据库中的数据存储在集合（Collections）中，Java API中通过`MongoCollection<Document>`对象来操作： ```java MongoCollection<Document> collection = database.getCollection("myCollection...
在本文中，我们将深入探讨“mongodb数据库的基本操作”，包括增、删、改、查以及分页功能。 首先，让我们从创建数据库开始。在MongoDB中，数据库是存储数据的基本单位。通过运行`use <database_name>`命令，你可以...
3. **数据导入方法**: 方法中提及的"构造化查询语言配置"（SQL配置）用于从Oracle数据库导出数据，SQL是用于管理和处理关系数据库的标准语言。而“bson格式配置”是指数据转换成BSON（Binary JSON）格式，这是...