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; 
}

}

待续......