Mongodb底层java驱动框架工具类使用

ewr212

然后使用某个随机数对文档进行查询高效，随机键还能添加索引，效率更高。合理选择，合理设计。


    import java.net.UnknownHostException;  
    import java.util.Date;  
    import java.util.List;  
      
    import com.mongodb.BasicDBList;  
    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.MongoException;  
    import com.nerd.mongo.config.ConfigFactory;  
    /**
     * MONGOS
     * @author chenlongquan
     *
     */  
    public class MongoUtil {  
         
        private final static ThreadLocal<Mongo> mongos = new ThreadLocal<Mongo>();  
         
        public static DB getdb(){  
            return getMongos().getDB(ConfigFactory.getMongoConfig().getDb());  
        }  
         
        public static Mongo getMongos() {  
            Mongo mongo = mongos.get();  
            if (mongo == null) {  
                try {  
                    mongo = new Mongo(ConfigFactory.getMongoConfig().getIp(),ConfigFactory.getMongoConfig().getPort());  
                    mongos.set(mongo);  
                } catch (UnknownHostException e) {  
                    e.printStackTrace();  
                } catch (MongoException e) {  
                    e.printStackTrace();  
                }  
            }  
            return mongo;  
        }  
         
        public static void close(){  
            Mongo mongo = mongos.get();  
            if(mongo!=null){  
                mongo.close();  
                mongos.remove();  
            }  
        }  
         
         
        /**
         * 获取集合（表）
         *  
         * @param collection
         */  
        public static DBCollection getCollection(String collection) {  
      
            return getdb().getCollection(collection);  
        }  
    ......................................................  

下面我们就可以在这上面的基础上对mongodb进行基本的crud操作

例如：



    /**
         * 插入
         *  
         * @param collection
         * @param o 插入
         *     
         */  
        public static void insert(String collection, DBObject o) {  
              
            getCollection(collection).insert(o);  
        }  
      
        /**
         * 批量插入
         *  
         * @param collection
         * @param list
         *            插入的列表
         */  
        public void insertBatch(String collection, List<DBObject> list) {  
      
            if (list == null || list.isEmpty()) {  
                return;  
            }  
      
            getCollection(collection).insert(list);  
      
        }  


测试用例：



    insert("user1",  
                    new BasicDBObject().append("name", "admin3").append("type", "2").append("score", 70)  
                         .append("level", 2).append("inputTime", new Date().getTime()));  


工具类使用：



    /**
         * 删除
         *  
         * @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<DBObject> list) {  
      
            if (list == null || list.isEmpty()) {  
                return;  
            }  
      
            for (int i = 0; i < list.size(); i++) {  
                getCollection(collection).remove(list.get(i));  
            }  
        }  
      
         
        /**
         * 更新
         *  
         * @param collection
         * @param q
         *            查询条件
         * @param setFields
         *            更新对象
         */  
        public static void update(String collection, DBObject q, DBObject setFields) {  
      
            getCollection(collection).updateMulti(q,  
                    new BasicDBObject("$set", setFields));  
        }  
      
        /**
         * 查找集合所有对象
         *  
         * @param collection
         */  
        public static List<DBObject> findAll(String collection) {  
      
            return getCollection(collection).find().toArray();  
        }  
      
        /**
         * 按顺序查找集合所有对象
         *  
         * @param collection
         *            数据集
         * @param orderBy
         *            排序
         */  
        public static List<DBObject> findAll(String collection, DBObject orderBy) {  
      
            return getCollection(collection).find().sort(orderBy)  
                    .toArray();  
        }  
      
        /**
         * 查找（返回一个对象）
         *  
         * @param collection
         * @param q
         *            查询条件
         */  
        public static DBObject findOne(String collection, DBObject q) {  
      
            return getCollection(collection).findOne(q);  
        }  
      
        /**
         * 查找（返回一个对象）
         *  
         * @param collection
         * @param q
         *            查询条件
         * @param fileds
         *            返回字段
         */  
        public static DBObject findOne(String collection, DBObject q, DBObject fileds) {  
      
            return getCollection(collection).findOne(q, fileds);  
        }  
      
         
      
        /**
         * 分页查找集合对象，返回特定字段
         *  
         * @param collection
         * @param q
         *            查询条件
         * @param fileds
         *            返回字段
         * @pageNo 第n页
         * @perPageCount 每页记录数
         */  
        public static List<DBObject> findLess(String collection, DBObject q, DBObject fileds, int pageNo,  
                int perPageCount) {  
      
            return getCollection(collection).find(q, fileds)  
                    .skip((pageNo - 1) * perPageCount).limit(perPageCount)  
                    .toArray();  
        }