MongoDBManager

MongoBD常用操作符查询

public class MongoDBManager {

    private Mongo mg = null;
    private DB db = null;

    private final static Map instances = new ConcurrentHashMap();

    /**
     * 实例化
     * 
     * @return MongoDBManager对象
     */
    static {
        getInstance(\"db\");// 初始化默认的MongoDB数据库
    }

    public static MongoDBManager getInstance() {

        return getInstance(\"db\");// 配置文件默认数据库前缀为db
    }

    public static MongoDBManager getInstance(String dbName) {

        MongoDBManager mm = instances.get(dbName);
        if (mm == null) {
            mm = getNewInstance(dbName);
            instances.put(dbName, mm);
        }

        return mm;
    }

    private static synchronized MongoDBManager getNewInstance(String dbName) {

        MongoDBManager mm = new MongoDBManager();
        try {
            mm.mg = new Mongo(getProperty(\"mongodb.properties\", dbName
                    + \".host\"), Integer.parseInt(getProperty(
                    \"mongodb.properties\", dbName + \".port\")));
            mm.db = mm.mg.getDB(getProperty(\"mongodb.properties\",
                    dbName + \".dbname\"));
        } catch (Exception e) {
            System.out.print(\"Can\'t connect \" + dbName + \" MongoDB!\");
        }

        return mm;
    }

    /**
     * 根据properties文件的key获取value
     * 
     * @param filePath
     *            properties文件路径
     * @param key
     *            属性key
     * @return 属性value
     */
    private static String getProperty(String filePath, String key) {
        Properties props = new Properties();
        try {
            InputStream in = new BufferedInputStream(new FileInputStream(filePath));
            props.load(in);
            String value = props.getProperty(key);
            return value;
        } catch (Exception e) {
            return null;
        }
    }

    /**
     * 获取集合（表）
     * 
     * @param collection
     */
    public DBCollection getCollection(String collection) {

        return this.db.getCollection(collection);
    }

    /**
     * ----------------------------------分割线------------------------------------
     */

    /**
     * 插入
     * 
     * @param collection
     * @param o
     *            插入
     */
    public void insert(String collection) {
     //添加自增的键
     BasicDBObject doc=new BasicDBObject();
     DBCursor idcursor = getCollection(collection).find().sort(new BasicDBObject(\"id\", -1)).limit(1);
            if (idcursor.hasNext()) {
                doc.put(\"id\", Integer.parseInt(idcursor.next().get(\"id\").toString()) + 1);
            } else {
                doc.put(\"id\", 1);
            }
            doc.append(\"name\",\"张三\");
            doc.append(\"age\"，18);
        getCollection(collection).save(doc);
    }
    /**
     * 插入
     * 
     * @param collection
     * @param o
     *           插入
     */
    public void insert2(String collection) {
     //添加自增的键,覆盖mongodb自带的_id
     BasicDBObject doc=new BasicDBObject();
     DBCursor idcursor = getCollection(collection).find().sort(new BasicDBObject(\"_id\", Integer.valueOf(-1))).limit(1);
                if (idcursor.length()>0){
                  obj.put(\"_id\", Integer.valueOf(Integer.parseInt(idcursor.next().get(\"_id\").toString()) + 1));
                  idcursor.close();
                }else {
                  obj.put(\"_id\", Integer.valueOf(1));
                }
            doc.append(\"name\",\"张三\");
            doc.append(\"age\"，18);
        getCollection(collection).save(doc);
    }

    /**
     * 批量插入
     * 
     * @param collection
     * @param list
     *            插入的列表
     */
    public void insertBatch(String collection, List list) {

        if (list == null || list.isEmpty()) {
            return;
        }

        getCollection(collection).insert(list);

    }

    /**
     * 删除
     * 
     * @param collection
     * @param q
     *            查询条件
     */
    public void delete(String collection, DBObject q) {

        getCollection(collection).remove(q);
    }

    /**
     * 批量删除
     * 
     * @param collection
     * @param list
     *            删除条件列表
     */
    public void deleteBatch(String collection, List list) {

        if (list == null || list.isEmpty()) {
            return;
        }

        for (int i = 0; i < list.size(); i++) {
            getCollection(collection).remove(list.get(i));
        }
    }

    /**
     * 计算集合总条数
     * 
     * @param collection
     */
    public long getCount(String collection) {

        return getCollection(collection).find().count();
    }

    /**
     * 计算满足条件条数
     * 
     * @param collection
     * @param q
     *         查询条件
     */

    public long getCount(String collection, DBObject q) {

        return getCollection(collection).getCount(q);
    }

    /**
     * 更新
     * 
     * @param collection
     * @param q
     *          查询条件
     * @param setFields
     *          更新对象
     */
    public void update(String collection, DBObject q, DBObject setFields) {
        //upsert与Multi为boolean类型，upsert默认为flase不存在则不插入。multi默认为flase不更新多条。
        //反之upsert为true时为不存在则插入，multi为true时则根据条件可更新多条
        getCollection(collection).update(q,
                new BasicDBObject(\"$set\", setFields),upsert,Multi);
    }

    /**
     * 查找集合所有对象
     * 
     * @param collection
     */
    public List findAll(String collection) {

        return getCollection(collection).find().toArray();
    }

    /**
     * 按顺序查找集合所有对象
     * 
     * @param collection
     *            数据集
     * @param orderBy
     *            排序
     */
    public List findAll(String collection, DBObject orderBy) {

        return getCollection(collection).find().sort(orderBy)
                .toArray();
    }

    /**
     * 查找（返回一个对象）
     * 
     * @param collection
     * @param q
     *            查询条件
     */
    public DBObject findOne(String collection, DBObject q) {

        return getCollection(collection).findOne(q);
    }

    /**
     * 查找（返回一个对象）
     * 
     * @param collection
     * @param q
     *            查询条件
     * @param fileds
     *            返回字段
     */
    public DBObject findOne(String collection, DBObject q, DBObject fileds) {

        return getCollection(collection).findOne(q, fileds);
    }

    /**
     * 查找返回特定字段（返回一个List）
     * 
     * @param collection
     * @param q
     *            查询条件
     * @param fileds
     *            返回字段
     */
    public List findLess(String collection, DBObject q, DBObject fileds) {

        DBCursor c = getCollection(collection).find(q, fileds);
        if (c != null)
            return c.toArray();
        else
            return null;
    }

    /**
     * 查找返回特定字段（返回一个List）
     * 
     * @param collection
     * @param q
     *            查询条件
     * @param fileds
     *            返回字段
     * @param orderBy
     *            排序
     */
    public List findLess(String collection, DBObject q, DBObject fileds, DBObject orderBy) {

        DBCursor c = getCollection(collection).find(q, fileds).sort(orderBy);
        if (c != null)
            return c.toArray();
        else
            return null;
    }
    /**
    *regex模糊查询
    *@param q
    *  模糊查询字段
    */
    public List Regex(String collection,String name){
        BasicDBObject doc=new BasicDBObject();
        doc.append(\"name\",new BasicDBObject(\"$regex\",name));
        List list=new ArrayList();
        list=getCollection(collection).find(doc).toArray();
        return list;
    }
    /**
    *exists是否存在name字段
    *存在返回true，不存在返回flase
    */
    public boolean Exists(String collection){
        BasicDBObject doc = new BasicDBObject()
        doc.append(\"name\",new BasicDBObject(\"$exists\", true));
        List list=new ArrayList();
        list=getCollection(collection).find(doc).toArray();
        if(list!=null&&list.size>0){
            return true;
        }
        return false;
    }
    /**
    *查询年龄大于20岁的所有数据
    *$gt
    */
    public List FindByAge(String collection){
        List list=new ArrayList();
        BasicDBObject doc=new BasicDBObject();
        doc.append(\"Age\",new BasicDBObject(\"$gt\",20));
        list=getCollection(collection).find(doc).toArray();
        return list;
    }
    /**
    *查询年龄20-30岁之间的所有数据
    *$lte，$gt
    */
    public List FindByAge2(String collection){
        List list=new ArrayList();
        BasicDBObject doc=new BasicDBObject();
        doc.append(\"Age\",new BasicDBObject(\"$gt\",20));
        doc.append(\"Age\",new BasicDBObject(\"$lte\",30));
        list=getCollection(collection).find(doc).toArray();
        return list;
    }
    /**
    *根据q条件存在则num字段自加num，不存在则创建num
    *$inc
    */
    public void FindByAge2(String collection,DBObject q,int num){
        getCollection(collection).update(q,new BasicDBObject(\"$inc\", new BasicDBObject(\"num\", num)));

    }

    /**
     * 分页查找集合对象，返回特定字段
     * 
     * @param collection
     * @param q
     *            查询条件
     * @param fileds
     *            返回字段
     * @pageNo 第n页
     * @perPageCount 每页记录数
     */
    public List findLess(String collection, DBObject q, DBObject fileds, int pageNo,
            int perPageCount) {

        return getCollection(collection).find(q, fileds)
                .skip((pageNo - 1) * perPageCount).limit(perPageCount)
                .toArray();
    }

    /**
     * 按顺序分页查找集合对象，返回特定字段
     * 
     * @param collection
     *            集合
     * @param q
     *            查询条件
     * @param fileds
     *            返回字段
     * @param orderBy
     *            排序
     * @param pageNo
     *            第n页
     * @param perPageCount
     *            每页记录数
     */
    public List findLess(String collection, DBObject q, DBObject fileds, DBObject orderBy,
            int pageNo, int perPageCount) {

        return getCollection(collection).find(q, fileds)
                .sort(orderBy).skip((pageNo - 1) * perPageCount)
                .limit(perPageCount).toArray();
    }

    /**
     * 查找（返回一个List）
     * 
     * @param collection
     * @param q
     *            查询条件
     */
    public List find(String collection, DBObject q) {

        DBCursor c = getCollection(collection).find(q);
        if (c != null)
            return c.toArray();
        else
            return null;
    }

    /**
     * 按顺序查找（返回一个List）
     * 
     * @param collection
     * @param q
     *            查询条件
     * @param orderBy
     *            排序
     */
    public List find(String collection, DBObject q, DBObject orderBy) {

        DBCursor c = getCollection(collection).find(q).sort(orderBy);
        if (c != null)
            return c.toArray();
        else
            return null;
    }

    /**
     * 分页查找集合对象
     * 
     * @param collection
     * @param q
     *            查询条件
     * @pageNo 第n页
     * @perPageCount 每页记录数
     */
    public List find(String collection, DBObject q, int pageNo,
            int perPageCount) {

        return getCollection(collection).find(q)
                .skip((pageNo - 1) * perPageCount).limit(perPageCount)
                .toArray();
    }

    /**
     * 按顺序分页查找集合对象
     * 
     * @param collection
     *            集合
     * @param q
     *            查询条件
     * @param orderBy
     *            排序
     * @param pageNo
     *            第n页
     * @param perPageCount
     *            每页记录数
     */
    public List find(String collection, DBObject q, DBObject orderBy,
            int pageNo, int perPageCount) {

        return getCollection(collection).find(q)
                .sort(orderBy).skip((pageNo - 1) * perPageCount)
                .limit(perPageCount).toArray();
    }

    /**
     * distinct操作
     * 
     * @param collection
     *            集合
     * @param field
     *            distinct字段名称
     */
    public Object[] distinct(String collection, String field) {

        return getCollection(collection).distinct(field).toArray();
    }

    /**
     * distinct操作
     * 
     * @param collection
     *            集合
     * @param field
     *            distinct字段名称
     * @param q
     *            查询条件
     */
    public Object[] distinct(String collection, String field, DBObject q) {

        return getCollection(collection).distinct(field, q).toArray();
    }

    /**
     * group分组查询操作，返回结果少于10,000keys时可以使用
     * 
     * @param collection
     *            集合
     * @param key
     *            分组查询字段
     * @param q
     *            查询条件
     * @param reduce
     *            reduce Javascript函数，如：function(obj, out){out.count++;out.csum=obj.c;}
     * @param finalize
     *            reduce function返回结果处理Javascript函数，如：function(out){out.avg=out.csum/out.count;}
     */
    public BasicDBList group(String collection, DBObject key, DBObject q, DBObject initial, String reduce, String finalize) {

        return ((BasicDBList)getCollection(collection).group(key, q, initial, reduce, finalize));
    }

    /**
     * group分组查询操作，返回结果大于10,000keys时可以使用
     * 
     * @param collection
     *            集合
     * @param map
     *            映射javascript函数字符串，如：function(){ for(var key in this) { emit(key,{count:1}) } }
     * @param reduce
     *            reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var i in emits){ total+=emits[i].count;  } return {count:total}; }
     * @param q
     *            分组查询条件
     * @param orderBy
     *            分组查询排序
     */


    /**
     * group分组分页查询操作，返回结果大于10,000keys时可以使用
     * 
     * @param collection
     *            集合
     * @param map
     *            映射javascript函数字符串，如：function(){ for(var key in this) { emit(key,{count:1}) } }
     * @param reduce
     *            reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var i in emits){ total+=emits[i].count;  } return {count:total}; }
     * @param q
     *            分组查询条件
     * @param orderBy
     *            分组查询排序
     * @param pageNo
     *            第n页
     * @param perPageCount
     *            每页记录数
     */


    /**
     * group分组查询操作，返回结果大于10,000keys时可以使用
     * 
     * @param collection
     *            集合
     * @param map
     *            映射javascript函数字符串，如：function(){ for(var key in this) { emit(key,{count:1}) } }
     * @param reduce
     *            reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var i in emits){ total+=emits[i].count;  } return {count:total}; }
     * @param outputCollectionName
     *            输出结果表名称
     * @param q
     *            分组查询条件
     * @param orderBy
     *            分组查询排序
     */
    public List mapReduce(String collection, String map, String reduce, 
            String outputCollectionName, DBObject q, DBObject orderBy) {

        if (!db.collectionExists(outputCollectionName)) {
            getCollection(collection).mapReduce(map, reduce, outputCollectionName, q);
        }

        return getCollection(outputCollectionName).find(null,new BasicDBObject(\"_id\",false))
                .sort(orderBy).toArray();
    }

    /**
     * group分组分页查询操作，返回结果大于10,000keys时可以使用
     * 
     * @param collection
     *            集合
     * @param map
     *            映射javascript函数字符串，如：function(){ for(var key in this) { emit(key,{count:1}) } }
     * @param reduce
     *            reduce Javascript函数字符串，如：function(key,emits){ total=0; for(var i in emits){ total+=emits[i].count;  } return {count:total}; }
     * @param outputCollectionName
     *            输出结果表名称
     * @param q
     *            分组查询条件
     * @param orderBy
     *            分组查询排序
     * @param pageNo
     *            第n页
     * @param perPageCount
     *            每页记录数
     */
    public List mapReduce(String collection, String map, String reduce, 
            String outputCollectionName, DBObject q, DBObject orderBy, int pageNo, int perPageCount) {

        if (!db.collectionExists(outputCollectionName)) {
            getCollection(collection).mapReduce(map, reduce, outputCollectionName, q);
        }

        return getCollection(outputCollectionName).find(null,new BasicDBObject(\"_id\",false))
                .sort(orderBy).skip((pageNo - 1) * perPageCount)
                .limit(perPageCount).toArray();
    }

    }

如有疑问，欢迎大家一起探讨，可联系QQ群：259182457
MongoDB更多学习资料点击进入下载页