mongodb json

对mongodb数据的json的相关操作

package com.nextmap.jdbc.mongodb;

import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.regex.Pattern;
import org.apache.commons.lang3.StringUtils;
import com.alibaba.fastjson.JSONException;
import com.alibaba.fastjson.JSONObject;
import com.google.gson.Gson;
import com.mongodb.BasicDBObject;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.WriteConcern;
import com.mongodb.util.JSON;

/**
 * Mongo数据库通用操作类
 *  
 * @date 2015-12-20 下午9:06:30
 * @version Beta
 *   
 */
public class MongoDBOperator {
	private Mongo mongo = null;
	private Gson gson = null;
	public MongoDBOperator(Mongo mongo){
		this.mongo = mongo;
	}
	
	public MongoDBOperator(
			String dbHost, 
			String dbPort,
			String username, 
			String password) throws Exception, UnknownHostException{
		if(StringUtils.isBlank(username) && StringUtils.isBlank(password))
			this.mongo = 
			MongoBase.generateMongo(dbHost, dbPort);
		else
			this.mongo = 
				MongoBase.generateMongo(dbHost, dbPort, username, password);
		gson = new Gson();
	}
	
	public MongoDBOperator(
			String dbHost, 
			String dbPort) throws Exception, UnknownHostException{
		this.mongo = 
				MongoBase.generateMongo(dbHost, dbPort);
		gson = new Gson();
	}
	
	/**
	 * 获取数据库中指定数据集的第1条文档. 以Json字符串返回.
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 关键字字段
	 * @param keyValue 关键字值
	 * @param fieldFilter 字段过滤映射表
	 * @return 第1条文档的Json字符串
	 *
	 */
	public String getDocumentAsJsonStr(
			String dbName, 
			String colName,
			String keyName,
			Object keyValue,
			Map<String, Boolean> fieldFilter){
		String jsonStr = null;
		List<String> result = getDocumentsAsJsonStrList(dbName, colName, keyName, keyValue, 0, 1, fieldFilter);
		if((result != null)&&(result.size() > 0)){
			jsonStr = result.get(0);
		}
		
		return jsonStr;
	}
	
	/**
	 * 获取符合查询关键字的数据库中指定数据集的文档集合. 结果以Json字符串列表形式返回
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 关键字字段
	 * @param keyValue 关键字值
	 * @param skip 跳过的文档数
	 * @param limit 返回的文档数上限
	 * @param fieldFilter 字段过滤映射表
	 * @return 字符串列表文档集合
	 * 
	 * 字段过滤映射表:</br>
	 * "String-Boolean"键值对</br>
	 * String: 字段名. Boolean: true表示该字段在结果集合中出现; false表示该字段不出现.
	 * 
	 * @version 1.0
	 * @author Zhu Haichuan
	 * @update 2015-12-23 下午3:31:30
	 */
	public List<String> getDocumentsAsJsonStrList(
			String dbName, 
			String colName,
			String keyName,
			Object keyValue,
			int skip,
			int limit,
			Map<String, Boolean> fieldFilter){
		List<String> result = new ArrayList<>();
		
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		BasicDBObject fields = new BasicDBObject();
		if(fieldFilter != null && fieldFilter.size() > 0){
			// 过滤结果字段
			for(Entry<String, Boolean> entry : fieldFilter.entrySet()){
				if(entry.getValue()){
					fields.put(entry.getKey(), 1);
				}else{
					fields.put(entry.getKey(), 0);
				}
			}
		}
		
		BasicDBObject query = new BasicDBObject(keyName, keyValue);
		DBCursor dbCursor = dbCollection.find(query, fields).skip(skip).limit(limit);
		
		while(dbCursor.hasNext()){
			DBObject dbObject = dbCursor.next();
			result.add(dbObject.toString());
		}
		dbCursor.close();
		return result;
	}
	
	/**
	 * 插入或更新Json字符串对象至数据库
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 关键字名称
	 * @param jsonStr Json字符串
	 * @return 完成操作记录数
	 * 
	 * @version 1.0
	 * @author Zhu Haichuan
	 * @update 2015年12月24日 下午9:33:23
	 */
	public int insupJsonStrToCollection(
			String dbName, 
			String colName, 
			String keyName, 
			String jsonStr){
		int result = 0;
		DBObject dbObject = (DBObject) JSON.parse(jsonStr); //解析json字符串为DBObject对象

		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		BasicDBObject query = new BasicDBObject(keyName, dbObject.get(keyName));
		/*DBCursor dbCursor = dbCollection.find(query);
		if(dbCursor.count() > 0){
			
		}*/
		result = dbCollection.update(query, dbObject, true, false, WriteConcern.SAFE).getN();
		
		return result;
	}
	
	/**
	 * 删除数据库中记录
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 关键字名称
	 * @param keyValue Json字符串
	 * @return 完成操作记录数
	 */
	public int deleteFromCollection(
			String dbName, 
			String colName,
			String keyName,
			Object keyValue
			){
		int result = 0;
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		BasicDBObject query = new BasicDBObject();
		query.put(keyName, keyValue);
		result = dbCollection.remove(query, WriteConcern.SAFE).getN();
		
		return result;
	}
	
	/**
	 * 
	 * 插入Json字符串列表对象至数据库. 如果对象存在则更新.
	 * 
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param jsonStrList 字符串列表
	 * @return 成功插入数量
	 * 
	 * @version 1.0
	 * @author Zhu Haichuan
	 * @update 2015-12-23 上午9:10:43
	 */
	@Deprecated
	public int insupJsonStrListToCollection(String dbName, String colName, List<String> jsonStrList){
		int result = 0;
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		for(String jsonString : jsonStrList){
			DBObject dbObject = (DBObject) JSON.parse(jsonString); //解析json字符串为DBObject对象
			result = result +dbCollection.update(dbObject, dbObject, 
					true, false, WriteConcern.SAFE).getN(); // 对象存在则更新, 否则插入
		}
		return result;
	}
	
	
	/**
	 * 插入Json字符串列表对象至数据库. 如果对象存在则更新.
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 关键字名称
	 * @param jsonStrList 字符串列表
	 * @return 成功插入数量
	 * 
	 * @version 1.0
	 * @author Zhu Haichuan
	 * @update 2015年12月13日 上午9:58:18
	 */
	public int insupJsonStrListToCollection(String dbName, String colName, String keyName, List<String> jsonStrList){
		int result = 0;
		
		for(String jsonString : jsonStrList){
			result = result + insupJsonStrToCollection(dbName, colName, keyName, jsonString);
		}	
		return result;
	}
	
	/**
	 * 插入列表对象至数据库.
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param jsonStrList 数据对象列表
	 * @return 成功插入数量
	 * 
	 */
	public int insJsonStrListToCollection(String dbName, String colName, List<String> jsonStrList){
		int result = 0;
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		List<DBObject> dbObjects = new ArrayList<>();
		for(String jsonString : jsonStrList){
			DBObject dbObject = (DBObject) JSON.parse(jsonString); //解析json字符串为DBObject对象
			dbObjects.add(dbObject);
		}
		result = dbCollection.insert(dbObjects, WriteConcern.SAFE).getN();
		return result;
	}
	
	/**
	 * 获取数据库中指定数据集的文档数量
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @return 文档数量
	 * 
	 */
	public long getDocumnetSize(String dbName, String colName){
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		return dbCollection.count();
	}
	
	/**
	 * 获取数据库中指定数据集的文档. 以JSONObject列表返回
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param skip 跳过的文档数
	 * @param limit 返回的文档数上限.
	 * @param fieldFilter 字段过滤映射表
	 * @return JSONObject列表文档集合
	 * 
	 * 字段过滤映射表:</br>
	 * "String-Boolean"键值对</br>
	 * String: 字段名. Boolean: true表示该字段在结果集合中出现; false表示该字段不出现.
	 * 
	 * @version 1.0
	 * @author Zhu Haichuan
	 * @update 2015-12-26 下午3:31:30
	 */
	public List<JSONObject> getDocumentsAsJSONObject(
			String dbName, 
			String colName,
			int skip,
			int limit,
			Map<String, Boolean> fieldFilter){
		List<JSONObject> result = new ArrayList<>();
		
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		BasicDBObject fields = new BasicDBObject();
		if(fieldFilter != null && fieldFilter.size() > 0){
			// 过滤结果字段
			for(Entry<String, Boolean> entry : fieldFilter.entrySet()){
				if(entry.getValue()){
					fields.put(entry.getKey(), 1);
				}else{
					fields.put(entry.getKey(), 0);
				}
			}
		}
		DBCursor dbCursor = dbCollection.find(null, fields).skip(skip).limit(limit);
		
		while(dbCursor.hasNext()){
			DBObject dbObject = dbCursor.next();
			try {
				JSONObject oneJson = JSONObject.parseObject(dbObject.toString());
				result.add(oneJson);
			} catch (JSONException e) {
				e.printStackTrace();
			}
			
		}
		dbCursor.close();
		return result;
	}
	
	/**
	 * 获取符合查询关键字的数据库中指定数据集的文档集合. 结果以Json字符串列表形式返回
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 关键字字段
	 * @param keyValue 关键字值
	 * @param skip 跳过的文档数
	 * @param limit 返回的文档数上限
	 * @param fieldFilter 字段过滤映射表
	 * @return JSONObject 列表文档集合
	 * 
	 * 字段过滤映射表:</br>
	 * "String-Boolean"键值对</br>
	 * String: 字段名. Boolean: true表示该字段在结果集合中出现; false表示该字段不出现.
	 * 
	 * @version 1.0
	 * @author Zhu Haichuan
	 * @update 2015-12-26 下午2:16:27
	 */
	public List<JSONObject> getDocumentsAsJSONObject(
			String dbName, 
			String colName,
			String keyName,
			Object keyValue,
			int skip,
			int limit,
			Map<String, Boolean> fieldFilter){
		List<JSONObject> result = new ArrayList<>();
		
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		BasicDBObject fields = new BasicDBObject();
		if(fieldFilter != null && fieldFilter.size() > 0){
			// 过滤结果字段
			for(Entry<String, Boolean> entry : fieldFilter.entrySet()){
				if(entry.getValue()){
					fields.put(entry.getKey(), 1);
				}else{
					fields.put(entry.getKey(), 0);
				}
			}
		}
		
		BasicDBObject query = new BasicDBObject(keyName, keyValue);
		DBCursor dbCursor = dbCollection.find(query, fields).skip(skip).limit(limit);
		
		while(dbCursor.hasNext()){
			DBObject dbObject = dbCursor.next();
			try {
				JSONObject oneJson = JSONObject.parseObject(dbObject.toString());
				result.add(oneJson);
			} catch (JSONException e) {
				e.printStackTrace();
			}
			
		}
		dbCursor.close();
		return result;
	}
	
	/**
	 * 获取符合模糊查询关键字的数据库中指定数据集的文档集合. 结果以Json字符串列表形式返回
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 关键字字段
	 * @param keyValue 关键字值
	 * @param skip 跳过的文档数
	 * @param limit 返回的文档数上限
	 * @param fieldFilter 字段过滤映射表
	 * @return JSONObject列表文档集合
	 * 
	 * 字段过滤映射表:</br>
	 * "String-Boolean"键值对</br>
	 * String: 字段名. Boolean: true表示该字段在结果集合中出现; false表示该字段不出现.
	 * 
	 */
	public List<JSONObject> getDocumentsAsJSONObjectByRegex(
			String dbName, 
			String colName,
			String keyName,
			String keyValue,
			int skip,
			int limit,
			Map<String, Boolean> fieldFilter){
		List<JSONObject> result = new ArrayList<>();
		
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		BasicDBObject fields = new BasicDBObject();
		if(fieldFilter != null && fieldFilter.size() > 0){
			// 过滤结果字段
			for(Entry<String, Boolean> entry : fieldFilter.entrySet()){
				if(entry.getValue()){
					fields.put(entry.getKey(), 1);
				}else{
					fields.put(entry.getKey(), 0);
				}
			}
		}
		
		BasicDBObject query = new BasicDBObject(keyName, generateLikeStr(keyValue));
		DBCursor dbCursor = dbCollection.find(query, fields).skip(skip).limit(limit);
		
		while(dbCursor.hasNext()){
			DBObject dbObject = dbCursor.next();
			try {
				JSONObject oneJson = JSONObject.parseObject(dbObject.toString());
				result.add(oneJson);
			} catch (JSONException e) {
				e.printStackTrace();
			}
			
		}
		dbCursor.close();
		return result;
	}
	
	/**
	 * 用一句话说明这个方法做什么
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 关键字字段
	 * @param keyValue 关键字值
	 * @param andQuery 'and'查询条件列表
	 * @param fieldFilter 字段过滤映射表
	 * @return JSONObject列表文档集合
	 * 
	 * 字段过滤映射表:</br>
	 * "String-Boolean"键值对</br>
	 * String: 字段名. Boolean: true表示该字段在结果集合中出现; false表示该字段不出现.
	 * 
	 * @version 1.0
	 * @author Zhu Haichuan
	 * @update 2015-12-25 上午9:54:59
	 */
	public List<JSONObject> getDocumentsAsJSONObject(
			String dbName, 
			String colName,
			int skip,
			int limit,
			Map<String, Object> andQuery,
			Map<String, Boolean> fieldFilter){
		List<JSONObject> result = new ArrayList<>();
		
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		
		BasicDBObject fields = null;
		if(fieldFilter != null && fieldFilter.size() > 0){
			fields = new BasicDBObject();
			// 过滤结果字段
			for(Entry<String, Boolean> entry : fieldFilter.entrySet()){
				if(entry.getValue()){
					fields.put(entry.getKey(), 1);
				}else{
					fields.put(entry.getKey(), 0);
				}
			}
		}
		
		BasicDBObject query = null;
		if(andQuery !=null && andQuery.size() > 0){
			query = new BasicDBObject();
			// 添加and查询条件
			for(Entry<String, Object> entry : andQuery.entrySet()){
				query.put(entry.getKey(), entry.getValue());
			}
		}
		
		DBCursor dbCursor = dbCollection.find(query, fields).skip(skip).limit(limit);
		while(dbCursor.hasNext()){
			DBObject dbObject = dbCursor.next();
			try {
				JSONObject oneJson = JSONObject.parseObject(dbObject.toString());
				result.add(oneJson);
			} catch (JSONException e) {
				e.printStackTrace();
			}
			
		}
		dbCursor.close();
		
		return result;
	}
	
	/**
	 * 获取数据库中指定数据集的文档.
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param fieldFilter 字段过滤映射表
	 * @return 文档集合
	 * 
	 * 字段过滤映射表:</br>
	 * "String-Boolean"键值对</br>
	 * String: 字段名. Boolean: true表示该字段在结果集合中出现; false表示该字段不出现.
	 * 
	 * @version 1.0
	 * @author Zhu Haichuan
	 * @update 2015-12-23 下午3:16:02
	 */
	public List<JSONObject> getDocumentsAsJSONObject(
			String dbName, 
			String colName,
			Map<String, Boolean> fieldFilter){
		return getDocumentsAsJSONObject(dbName, colName, 0, 0, fieldFilter);
	}
	
	/**
	 * 插入Map<String,String>对象至数据库
	 *
	 * @param dbName 数据库名称
	 * @param colName 数据集名称
	 * @param keyName 对象关键字段名称
	 * @param attrMap 属性列表
	 * @return 插入数量
	 * 
	 */
	public int insMapToCollection(String dbName, String colName, 
			String keyName, Map<String, String> attrMap){
		int result = 0;
		
		String value = attrMap.get(keyName);
		if(StringUtils.isBlank(value))
			return result;
		
		DB db = mongo.getDB(dbName);
		DBCollection dbCollection = db.getCollection(colName);
		BasicDBObject query = new BasicDBObject(keyName, value);
		DBCursor dbCursor = dbCollection.find(query);
		if(dbCursor.count()>0)
			return result;
		DBObject dbObject = (DBObject) JSON.parse(gson.toJson(attrMap)); //解析json字符串为DBObject对象
		result = dbCollection.insert(dbObject, WriteConcern.SAFE).getN();
		/*DBObject dbObject = (DBObject) JSON.parse(jsonStr); //解析json字符串为DBObject对象
		result = dbCollection.update(dbObject, dbObject, 
				true, false, WriteConcern.SAFE).getN(); // 如果对象存在则更新
*/		return result;
	}
	
	//模糊查询
	 private BasicDBObject generateLikeStr(String findStr) {
	     Pattern pattern = Pattern.compile(findStr);
	     return new BasicDBObject("$regex", pattern);
	 }
	
	public void closeDB(){
		if(mongo != null) {
			mongo.close();
			mongo = null;
		}
			
	}
}