MongoDB CRUD操作

public class BaseDao {
    private static Log log = LogFactory.getLog(BaseDao.class);
    
    public static final String $SET = "$set";

    protected String _ns;
    protected DBCollection _coll;
    protected DB _db;
    protected final static String __id = "_id";

    public BaseDao(String _ns) {
        this._ns = _ns;
        this._db = MongoUtil.getDB();
        this._coll = this._db.getCollection(this._ns);
    }

    /**
     * 插入
     *
     * @Title: insert
     * @Description: TODO
     * @param @param basicDBObject
     * @param @return
     * @return WriteResult
     * @throws
     */
    public WriteResult insert(DBObject basicDBObject) {
        try {
            return _coll.insert(basicDBObject, WriteConcern.SAFE);
        } catch (Exception e) {
            log.error("插入失败!" + e.getMessage(), e);
        }
        return null;
    }

    public WriteResult insert(List<DBObject> list) {
        try {
            return _coll.insert(list);
        } catch (Exception e) {
            log.error("批量插入失败!" + e.getMessage(), e);
        }
        return null;
    }
    
//    public void findAndModify(DBObject q, DBObject o){
//        try {
//            _coll.findAndModify(q, o);
//        } catch (Exception e) {
//            log.error("更新失败!" + e.getMessage(), e);
//        }
//    }

    /**
     * 插入(不报违反唯一索引)
     *
     * @Title: insert
     * @Description: TODO
     * @param @param basicDBObject
     * @param @return
     * @return WriteResult
     * @throws
     */
    public boolean insertIgnoreDupliException(DBObject basicDBObject) {
        try {
             _coll.insert(basicDBObject, WriteConcern.SAFE);
             return true;
        } catch (DuplicateKey e) {
            return false;
        } catch (Exception e) {
            log.error("插入失败!" + e.getMessage(), e);
            return false;
        }
    }

    /**
     * 查询所有
     *
     * @Title: findAll
     * @Description: TODO
     * @param @return
     * @return List<DBObject>
     * @throws
     */
    public List<DBObject> findAll() {
        return findAll(null, 0);
    }

    public List<DBObject> findAll(DBObject find) {
        return findAll(find, 0);
    }

    public List<DBObject> findAll(DBObject find, int limit) {
        return findAll(find, new BasicDBList(), limit);
    }

     //DBObject sort = new DBOject();

     // sort.put("表中列名",-1);降序，1为升序

    public List<DBObject> findAll(DBObject find, DBObject sort, int limit) {
        DBCursor cursor = _coll.find(find).sort(sort).limit(limit);
        return cursor.toArray();
    }

    public List<DBObject> findAll(DBObject find, DBObject keys, DBObject sort,
            int limit) {
        DBCursor cursor = _coll.find(find, keys).sort(sort).limit(limit);
        return cursor.toArray();
    }

    public DBObject findOne() {
        return _coll.findOne();
    }

    public DBObject findOne(Object _id) {
        return this.findOne(__id, _id);
    }

    public DBObject findOne(String key, Object value) {
        BasicDBObject find = new BasicDBObject();
        find.put(key, value);
        DBObject dbObject = _coll.findOne(find);
        return dbObject;
    }

    public DBObject findOne(DBObject find) {
        return _coll.findOne(find);
    }

    public DBObject findOne(DBObject find, DBObject fields) {
        return _coll.findOne(find, fields);
    }

    public WriteResult update(DBObject q, DBObject o) {
        try {
            return _coll.update(q, new BasicDBObject($SET,o));
        } catch (Exception e) {
            log.error("更新失败!" + e.getMessage(), e);
        }
        return null;
    }

//    public WriteResult update(DBObject q, DBObject o, boolean upsert,
//            boolean multi) {
//        try {
//            return _coll.update(q, o, upsert, multi);
//        } catch (Exception e) {
//            log.error("更新失败!" + e.getMessage(), e);
//        }
//        return null;
//    }

    public WriteResult remove(DBObject find) {
        if (find.keySet().size() == 0) {
            return null;
        }
        return _coll.remove(find);
    }

    public long count() {
        return _coll.count();
    }

    public long count(DBObject find) {
        return _coll.count(find);
    }
}