java調用MongodbAPI條件查詢

（一）、java調用api按條件查詢：

    (1.1).

        /**
* 根據類型和當天時間查詢關聯信息
* @param type 類型
* @param collection mongodb表
* @param dtype 數據類型
* @return
*/
public List<DBObject> findMongodb(String type,String collection,String dtype){
logger.info("查詢mongodb表："+collection+"；數據來源類型："+type+"；數據類型："+dtype);
//當前日期的前一天
String beforDate = DateUtils.getNowBeforDay();

BasicDBList list = new BasicDBList();
//按時間檢索前一天的數據
BasicDBObject dbo = new BasicDBObject();
dbo.append("commit_time", new BasicDBObject("$gte", beforDate+" 00:00:00"));
dbo.append("commit_time", new BasicDBObject("$lte", beforDate+" 23:59:59"));
//數據類型查詢
BasicDBObject db = new BasicDBObject();
db.append("data_type", CommonAttributes.getMap(dtype));
list.add(dbo);
list.add(db);
BasicDBObject d = new BasicDBObject();
d.put("$and", list);

return MongoDBManager.findForCommitTime(collection, d);
}

(1.2)

       /**
* 查詢包含baby_id這一列，並且beforDate<=ut<=beforDate的所有數據
* @param collection 表名
* @return
*/
public List<DBObject> findMongodbReview(String collection){
//當前日期的前一天
String beforDate = DateUtils.getNowBeforDay();
BasicDBList list = new BasicDBList();
//按時間檢索前一天的數據
BasicDBObject dbo = new BasicDBObject();

//ut,baby_id分別爲mongodb的列名
dbo.put("ut", new BasicDBObject("$gte", beforDate+" 00:00:00").append("$lte", beforDate+" 23:59:59"));
dbo.put("baby_id", new BasicDBObject("$exists", true));
list.add(dbo);
BasicDBObject d = new BasicDBObject();
d.put("$and", list);

return MongoDBManager.findForCommitTime(collection, dbo);
}

（二）、Mongodb單例簡單實現類

package com.mall.common.dao;

import java.util.ArrayList;
import java.util.List;
import java.util.Map;

import org.bson.types.ObjectId;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.mall.untils.PropertiesUtil;
import com.mongodb.BasicDBObject;
import com.mongodb.Bytes;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.DBObject;
import com.mongodb.Mongo;
import com.mongodb.MongoException;


/**
 * 操作mongodb公共類
 * @author liudu
 *
 */
@SuppressWarnings("deprecation")
public class MongoDBManager {

private static Logger logger = LoggerFactory.getLogger(MongoDBManager.class);
private static Mongo mg = null;
private static DB db = null;
private final static MongoDBManager mongoDbManager = new MongoDBManager();


/**
* 實例化
* 
* @return
* @throws Exception
*/
public static MongoDBManager getInstance() throws Exception {
return mongoDbManager;
}

static {
try {
mg = new Mongo(PropertiesUtil.getProperties("mongo.host"), Integer.parseInt(PropertiesUtil.getProperties("mongo.port")));
db = mg.getDB(PropertiesUtil.getProperties("mongo.database.dail"));
} catch (Exception e) {
logger.error("Can't connect MongoDB!");
} finally {
}
}


/**
* 獲取集合（表）
* 
* @param collection
*/
public static DBCollection getCollection(String collection) {
return db.getCollection(collection);
}

        //以下是簡單方法實現

/**
* 插入
* 
* @param collection
* @param map
*/
public static void insert(String collection, Map<String, Object> map) {
try {
DBObject dbObject = new BasicDBObject(map);
getCollection(collection).insert(dbObject);
} catch (MongoException e) {
logger.error("MongoException:" + e.getMessage());
}
}


/**
* 批量插入
* 
* @param collection
* @param list list類型爲map
*/
public static void insertBatch(String collection, List<Map<String, Object>> list) {
if (list == null || list.isEmpty()) {
return;
}
try {
List<DBObject> listDB = new ArrayList<DBObject>();
for (int i = 0; i < list.size(); i++) {
DBObject dbObject = new BasicDBObject(list.get(i));
listDB.add(dbObject);
}
getCollection(collection).insert(listDB);
} catch (MongoException e) {
logger.error("MongoException:" + e.getMessage());
}
}


/**
* 批量插入
* 
* @param collection
* @param list list類型爲DBObject
*/
public static void insertBatchDBObject(String collection, List<DBObject> list) {
if (list == null || list.isEmpty()) {
return;
}
try {
getCollection(collection).insert(list);
} catch (MongoException e) {
logger.error("MongoException:" + e.getMessage());
}
}

/**
* 刪除
* 
* @param collection
* @param map
*/
public static void delete(String collection, Map<String, Object> map) {
DBObject obj = new BasicDBObject(map);
getCollection(collection).remove(obj);
}

/**
* 批量刪除
* 
* @param collection 表名
* @param list
*/
public static void deleteBatch(String collection, List<Map<String, Object>> list) {
if (list == null || list.isEmpty()) {
return;
}
for (int i = 0; i < list.size(); i++) {
DBObject obj = new BasicDBObject(list.get(i));
getCollection(collection).remove(obj);
}
}


/**
* 計算滿足條件條數
* 
* @param collection 表名
* @param map 條件
*/
public static long getCount(String collection, Map<String, Object> map) {
BasicDBObject obj = new BasicDBObject(map);
return getCollection(collection).getCount(obj);
}


/**
* 計算集合總條數
* 
* @param collection 表名
*/
public static long getCount(String collection) {
return getCollection(collection).find().count();
}


/**
* 更新
* 
* @param collection 表名
* @param setFields 需要更新的參數列表
* @param whereFields 條件，相當於Sql裏面的where條件查詢
*/
public static void update(String collection, Map<String, Object> setFields,Map<String, Object> whereFields) {
    BasicDBObject q = new BasicDBObject(setFields);  
        BasicDBObject o = new BasicDBObject(whereFields);  
getCollection(collection).update(q, o);
}


/**
* 查找對象（根據主鍵_id）
* 
* @param collection 表名
* @param _id mongodb表的_id,相當於sql裏面的主鍵id
*/
public static DBObject findById(String collection, String _id) {
DBObject obj = new BasicDBObject();

//ObjectId.massageToObjectId(_id)該轉換方法已過時，新版本可以換其他轉換方法
obj.put("_id", ObjectId.massageToObjectId(_id));
return getCollection(collection).findOne(obj);
}


/**
* 查找集合所有對象
* 
* @param collection 表名
*/
public static List<DBObject> findAll(String collection) {
return getCollection(collection).find().toArray();
}


/**
* 查找（返回一個對象）
* 
* @param map 查詢條件集
* @param collection 表名
*/
public static DBObject findOne(String collection, Map<String, Object> map) {
DBCollection coll = getCollection(collection);
return coll.findOne(new BasicDBObject(map));
}


/**
* 查找（返回一個List<DBObject>）
* 
* @param map 條件集
* @param collection 表名
* @throws Exception
*/
public static List<DBObject> find(String collection, Map<String, Object> map) {
DBCollection coll = getCollection(collection);
DBCursor c = coll.find(new BasicDBObject(map));
if (c != null){
return c.toArray();
}else{
return null;
}
}

/**
* 根據時間(commit_time)查找（返回一個List<DBObject>）
* @param collection 表名
* @param dbo 查詢條件
* @return
*/
public static List<DBObject> findForCommitTime(String collection, BasicDBObject dbo) {

DBCollection coll = getCollection(collection);
DBCursor c = coll.find(dbo).addOption(Bytes.QUERYOPTION_NOTIMEOUT);//設置不超時查詢
if (c != null){
return c.toArray();
}
return null;
}
}

public class UtilsDate(){

/**
* 獲取當前日期的前一天:yyyy-MM-dd
* @return
*/
public static String getNowBeforDay(){ 
Calendar c = Calendar.getInstance(); 
c.setTime(new Date()); 
int day=c.get(Calendar.DATE); 
c.set(Calendar.DATE,day-1); 
String dayAfter=return new SimpleDateFormat("yyyy-MM-dd").format(c.getTime()); 
return dayAfter; 
}

}

待續......