MongoDB基本用法（增删改高级查询、mapreduce）

74 阅读 0 评论 49 点赞

我是靠谱客的博主神勇乌龟，最近开发中收集的这篇文章主要介绍MongoDB基本用法（增删改高级查询、mapreduce），觉得挺不错的，现在分享给大家，希望可以做个参考。

概述

分享一下我经常用到的自己写的mongo用法示例

该示例基于当前最新的mongo驱动，版本为mongo-2.10.1.jar,用junit写的单元测试。

TestCase.java

    Java代码   
    
  
 package com.wujintao.mongo;  
   
 import java.net.UnknownHostException;  
 import java.util.ArrayList;  
 import java.util.List;  
 import java.util.Set;  
 import java.util.regex.Pattern;  
   
 import org.junit.Test;  
   
 import com.mongodb.AggregationOutput;  
 import com.mongodb.BasicDBList;  
 import com.mongodb.BasicDBObject;  
 import com.mongodb.BasicDBObjectBuilder;  
 import com.mongodb.DB;  
 import com.mongodb.DBCollection;  
 import com.mongodb.DBCursor;  
 import com.mongodb.DBObject;  
 import com.mongodb.MapReduceCommand;  
 import com.mongodb.MapReduceOutput;  
 import com.mongodb.Mongo;  
 import com.mongodb.QueryBuilder;  
 import com.mongodb.WriteConcern;  
   
 public class TestCase {  
        //DBCursor cursor = coll.find(condition).addOption(Bytes.QUERYOPTION_NOTIMEOUT);//设置游标不要超时  
   
     @Test  
     /** 
      * 获取所有数据库实例 
      */  
     public void testGetDBS() {  
         List<String> dbnames = MongoUtil.getMong().getDatabaseNames();  
         for (String dbname : dbnames) {  
             System.out.println("dbname:" + dbname);  
         }  
     }  
   
     @Test  
     /** 
      * 删除数据库 
      */  
     public void dropDatabase() {  
         MongoUtil.getMong().dropDatabase("my_new_db");  
     }  
   
     @Test  
     /** 
      * 查询所有表名 
      */  
     public void getAllCollections() {  
         Set<String> colls = MongoUtil.getDB().getCollectionNames();  
         for (String s : colls) {  
             System.out.println(s);  
         }  
     }  
   
     @Test  
     public void dropCollection() {  
         MongoUtil.getColl("jellonwu").drop();  
     }  
   
     /** 
      * 添加一条记录 
      */  
     @Test  
     public void addData() {  
         DBCollection coll = MongoUtil.getColl("wujintao");  
         BasicDBObject doc = new BasicDBObject();  
         doc.put("name", "MongoDB");  
         doc.put("type", "database");  
         doc.put("count", 1);  
   
         BasicDBObject info = new BasicDBObject();  
         info.put("x", 203);  
         info.put("y", 102);  
         doc.put("info", info);  
         coll.insert(doc);  
         // 设定write concern，以便操作失败时得到提示  
         coll.setWriteConcern(WriteConcern.SAFE);  
     }  
   
     @Test  
     /** 
      * 创建索引 
      */  
     public void createIndex() {  
         MongoUtil.getColl("wujintao").createIndex(new BasicDBObject("i", 1));  
     }  
   
     @Test  
     /** 
      * 获取索引信息 
      */  
     public void getIndexInfo() {  
         List<DBObject> list = MongoUtil.getColl("hems_online").getIndexInfo();  
         for (DBObject o : list) {  
             System.out.println(o);  
         }  
     }  
   
     @Test  
     /** 
      * 添加多条记录 
      */  
     public void addMultiData() {  
         for (int i = 0; i < 100; i++) {  
             MongoUtil.getColl("wujintao").insert(  
                     new BasicDBObject().append("i", i));  
         }  
   
         List<DBObject> docs = new ArrayList<DBObject>();  
         for (int i = 0; i < 50; i++) {  
             docs.add(new BasicDBObject().append("i", i));  
         }  
         MongoUtil.getColl("wujintao").insert(docs);  
         // 设定write concern，以便操作失败时得到提示  
         MongoUtil.getColl("wujintao").setWriteConcern(WriteConcern.SAFE);  
     }  
   
     @Test  
     /** 
      * 查找第一条记录 
      */  
     public void findOne() {  
         DBObject myDoc = MongoUtil.getColl("wujintao").findOne();  
         System.out.println(myDoc);  
     }  
   
     @Test  
     /** 
      * 获取表中所有记录条数 
      */  
     public void count() {  
         System.out.println(MongoUtil.getColl("wujintao").getCount());  
         System.out.println(MongoUtil.getColl("wujintao").count());  
     }  
   
     @Test  
     /** 
      * 获取查询结果集的记录数 
      */  
     public void getCount() {  
         DBObject query = new BasicDBObject("name", "a");  
         long count = MongoUtil.getColl("wujintao").count(query);  
         System.out.println(count);  
     }  
   
     @Test  
     /** 
      * 查询所有结果 
      */  
     public void getAllDocuments() {  
         DBCursor cursor = MongoUtil.getColl("wujintao").find();  
         try {  
             while (cursor.hasNext()) {  
                 System.out.println(cursor.next());  
             }  
         } finally {  
             cursor.close();  
         }  
     }  
   
     @Test  
     /** 
      * 按照一个条件查询 
      */  
     public void queryByConditionOne() {  
         BasicDBObject query = new BasicDBObject();  
         query.put("name", "MongoDB");  
         DBCursor cursor = MongoUtil.getColl("wujintao").find(query);  
   
         try {  
             while (cursor.hasNext()) {  
                 System.out.println(cursor.next());  
             }  
         } finally {  
             cursor.close();  
         }  
     }  
   
     @Test  
     /** 
      * AND多条件查询,区间查询 
      */  
     public void queryMulti() {  
         BasicDBObject query = new BasicDBObject();  
         // 查询j不等于3,k大于10的结果集  
         query.put("j", new BasicDBObject("$ne", 3));  
         query.put("k", new BasicDBObject("$gt", 10));  
         DBCursor cursor = MongoUtil.getColl("wujintao").find(query);  
         try {  
             while (cursor.hasNext()) {  
                 System.out.println(cursor.next());  
             }  
         } finally {  
             cursor.close();  
         }  
     }  
   
     @Test  
     /** 
      * 区间查询 
      * select * from table where i >50 
      */  
     public void queryMulti2() {  
         BasicDBObject query = new BasicDBObject();  
         query = new BasicDBObject();  
         query.put("i", new BasicDBObject("$gt", 50)); // e.g. find all where i >  
         DBCursor cursor = MongoUtil.getColl("wujintao").find(query);  
         try {  
             while (cursor.hasNext()) {  
                 System.out.println(cursor.next());  
             }  
         } finally {  
             cursor.close();  
         }  
     }  
   
     @Test  
     /** 
      * 区间查询 
      * select * from table where 20 < i <= 30 
         //比较符    
         //"$gt"： 大于    
         //"$gte"：大于等于    
         //"$lt"： 小于    
         //"$lte"：小于等于    
         //"$in"： 包含    
      */  
     public void queryMulti3() {  
         BasicDBObject query = new BasicDBObject();  
         query = new BasicDBObject();  
   
         query.put("i", new BasicDBObject("$gt", 20).append("$lte", 30));  
         DBCursor cursor = MongoUtil.getColl("wujintao").find(query);  
         try {  
             while (cursor.hasNext()) {  
                 System.out.println(cursor.next());  
             }  
         } finally {  
             cursor.close();  
         }  
     }  
   
     /** 
      * 组合in和and select * from test_Table where (a=5 or b=6) and (c=5 or d = 6) 
      */  
     public void queryMulti4() {  
         BasicDBObject query11 = new BasicDBObject();  
         query11.put("a", 1);  
         BasicDBObject query12 = new BasicDBObject();  
         query12.put("b", 2);  
         List<BasicDBObject> orQueryList1 = new ArrayList<BasicDBObject>();  
         orQueryList1.add(query11);  
         orQueryList1.add(query12);  
         BasicDBObject orQuery1 = new BasicDBObject("$or", orQueryList1);  
   
         BasicDBObject query21 = new BasicDBObject();  
         query21.put("c", 5);  
         BasicDBObject query22 = new BasicDBObject();  
         query22.put("d", 6);  
         List<BasicDBObject> orQueryList2 = new ArrayList<BasicDBObject>();  
         orQueryList2.add(query21);  
         orQueryList2.add(query22);  
         BasicDBObject orQuery2 = new BasicDBObject("$or", orQueryList2);  
   
         List<BasicDBObject> orQueryCombinationList = new ArrayList<BasicDBObject>();  
         orQueryCombinationList.add(orQuery1);  
         orQueryCombinationList.add(orQuery2);  
   
         BasicDBObject finalQuery = new BasicDBObject("$and",  
                 orQueryCombinationList);  
         DBCursor cursor = MongoUtil.getColl("wujintao").find(finalQuery);  
     }  
   
     @Test  
     /** 
      * IN查询 
      * if i need to query name in (a,b); just use { name : { $in : ['a', 'b'] } } 
      * select * from things where name='a' or name='b' 
      * @param coll 
      */  
     public void queryIn() {  
         BasicDBList values = new BasicDBList();  
         values.add("a");  
         values.add("b");  
         BasicDBObject in = new BasicDBObject("$in", values);  
         DBCursor cursor = MongoUtil.getColl("wujintao").find(  
                 new BasicDBObject("name", in));  
         try {  
             while (cursor.hasNext()) {  
                 System.out.println(cursor.next());  
             }  
         } finally {  
             cursor.close();  
         }  
     }  
   
     @Test  
     /** 
      * 或查询 
      * select * from table where name  = '12' or title = 'p' 
      * @param coll 
      */  
     public void queryOr() {  
         QueryBuilder query = new QueryBuilder();  
         query.or(new BasicDBObject("name", 12), new BasicDBObject("title", "p"));  
         DBCursor cursor = MongoUtil.getColl("wujintao").find(query.get()).addSpecial("$returnKey", "");  
         try {  
             while (cursor.hasNext()) {  
                 System.out.println(cursor.next());  
             }  
         } finally {  
             cursor.close();  
         }  
     }  
       
     @Test  
     public void customQueryField() throws UnknownHostException{  
         Mongo mongo = new Mongo("localhost", 27017);  
         DB db = mongo.getDB("zhongsou_ad");  
         BasicDBObjectBuilder bulder = new BasicDBObjectBuilder();  
         bulder.add("times",1);  
         bulder.add("aid",1);  
         DBCursor cusor =  db.getCollection("ad_union_ad_c_1").find(new BasicDBObject(),bulder.get());  
         for (DBObject dbObject : cusor) {  
             System.out.println(dbObject);  
         }  
     }  
       
     @Test  
     public void mapReduce() throws UnknownHostException{  
         Mongo mongo = new Mongo("localhost", 27017);  
         DB db = mongo.getDB("zhongsou_ad");  
         /*** 
          *  book1 = {name : "Understanding JAVA", pages : 100} 
          *  book2 = {name : "Understanding JSON", pages : 200} 
          *  db.books.save(book1) 
          *  db.books.save(book2) 
          *  book = {name : "Understanding XML", pages : 300} 
          *  db.books.save(book) 
          *  book = {name : "Understanding Web Services", pages : 400} 
          *  db.books.save(book) 
          *  book = {name : "Understanding Axis2", pages : 150} 
          *  db.books.save(book)   
          *   
         var map = function() { 
             var category; 
             if ( this.pages >= 250 ) 
                 category = 'Big Books'; 
             else 
                 category = "Small Books"; 
             emit(category, {name: this.name}); 
         }; 
         var reduce = function(key, values) { 
             var sum = 0; 
             values.forEach(function(doc) { 
                 sum += 1; 
             }); 
             return {books: sum}; 
         };        
         var count  = db.books.mapReduce(map, reduce, {out: "book_results"}); 
          */  
         try {  
   
             DBCollection books = db.getCollection("books");  
   
             BasicDBObject book = new BasicDBObject();  
             book.put("name", "Understanding JAVA");  
             book.put("pages", 100);  
             books.insert(book);  
               
             book = new BasicDBObject();    
             book.put("name", "Understanding JSON");  
             book.put("pages", 200);  
             books.insert(book);  
               
             book = new BasicDBObject();  
             book.put("name", "Understanding XML");  
             book.put("pages", 300);  
             books.insert(book);  
               
             book = new BasicDBObject();  
             book.put("name", "Understanding Web Services");  
             book.put("pages", 400);  
             books.insert(book);  
             
             book = new BasicDBObject();  
             book.put("name", "Understanding Axis2");  
             book.put("pages", 150);  
             books.insert(book);  
               
             String map = "function() { "+   
                       "var category; " +    
                       "if ( this.pages >= 250 ) "+    
                       "category = 'Big Books'; " +  
                       "else " +  
                       "category = 'Small Books'; "+    
                       "emit(category, {name: this.name});}";  
               
             String reduce = "function(key, values) { " +  
                                      "var sum = 0; " +  
                                      "values.forEach(function(doc) { " +  
                                      "sum += 1; "+  
                                      "}); " +  
                                      "return {books: sum};} ";  
               
             MapReduceCommand cmd = new MapReduceCommand(books, map, reduce,  
               null, MapReduceCommand.OutputType.INLINE, null);  
   
             MapReduceOutput out = books.mapReduce(cmd);  
   
             for (DBObject o : out.results()) {  
              System.out.println(o.toString());  
             }  
            } catch (Exception e) {  
              e.printStackTrace();  
            }  
     }  
       
     @Test  
     public void GroupByManyField() throws UnknownHostException{  
         //此方法没有运行成功  
         Mongo mongo = new Mongo("localhost", 27017);  
         DB db = mongo.getDB("libary");  
         DBCollection books = db.getCollection("books");  
         BasicDBObject groupKeys = new BasicDBObject();  
         groupKeys.put("total", new BasicDBObject("$sum","pages"));  
           
         BasicDBObject condition = new BasicDBObject();  
         condition.append("pages", new BasicDBObject().put("$gt", 0));  
      
           
         String reduce = "function(key, values) { " +  
                 "var sum = 0; " +  
                 "values.forEach(function(doc) { " +  
                 "sum += 1; "+  
                 "}); " +  
                 "return {books: sum};} ";  
         /** 
          BasicDBList basicDBList = (BasicDBList)db.getCollection("mongodb中集合编码或者编码") 
                    .group(DBObject key,   --分组字段，即group by的字段 
                 DBObject cond,        --查询中where条件 
                 DBObject initial,     --初始化各字段的值 
                 String reduce,        --每个分组都需要执行的Function 
                 String finial         --终结Funciton对结果进行最终的处理 
          */  
         DBObject obj = books.group(groupKeys, condition,  new BasicDBObject(), reduce);  
         System.out.println(obj);  
           
         AggregationOutput ouput = books.aggregate(new BasicDBObject("$group",groupKeys));  
         System.out.println(ouput.getCommandResult());  
         System.out.println(books.find(new BasicDBObject("$group",groupKeys)));  
     }     
       
   
     @Test  
     /** 
      * 分页查询    
      */  
     public void pageQuery() {  
         DBCursor cursor = MongoUtil.getColl("wujintao").find().skip(0)  
                 .limit(10);  
         while (cursor.hasNext()) {  
             System.out.println(cursor.next());  
         }  
     }  
   
     /** 
      * 模糊查询 
      */  
     public void likeQuery() {  
         Pattern john = Pattern.compile("joh?n");  
         BasicDBObject query = new BasicDBObject("name", john);  
   
         // finds all people with "name" matching /joh?n/i  
         DBCursor cursor = MongoUtil.getColl("wujintao").find(query);  
     }  
   
     @Test  
     /** 
      * 条件删除    
      */  
     public void delete() {  
         BasicDBObject query = new BasicDBObject();  
         query.put("name", "xxx");  
         // 找到并且删除，并返回删除的对象  
         DBObject removeObj = MongoUtil.getColl("wujintao").findAndRemove(query);  
         System.out.println(removeObj);  
     }  
   
     @Test  
     /** 
      * 更新 
      */  
     public void update() {  
         BasicDBObject query = new BasicDBObject();  
         query.put("name", "liu");  
         DBObject stuFound = MongoUtil.getColl("wujintao").findOne(query);  
         stuFound.put("name", stuFound.get("name") + "update_1");  
         MongoUtil.getColl("wujintao").update(query, stuFound);  
     }  
   
   
 }  

这里面涉及到的MongoUtil.java如下：

    Java代码   
    
  
 package com.wujintao.mongo;  
   
 import java.net.UnknownHostException;  
   
 import org.apache.commons.logging.Log;  
 import org.apache.commons.logging.LogFactory;  
   
 import com.mongodb.DB;  
 import com.mongodb.DBCollection;  
 import com.mongodb.Mongo;  
   
   
 /** 
  * to see:http://www.mongodb.org/display/DOCS/Java+Driver+Concurrency 
  * Mongo工具类:设计为单例模式，每当月份发生变化，数据库连接名称就会发生变化，这是业务规则 
  * 因 MongoDB的Java驱动是线程安全的，对于一般的应用，只要一个Mongo实例即可，Mongo有个内置的连接池（池大小默认为10个）。 
  * 对于有大量写和读的环境中，为了确保在一个Session中使用同一个DB时，我们可以用以下方式保证一致性： 
  *   DB mdb = mongo.getDB('dbname'); 
  *   mdb.requestStart(); 
  *   // 业务代码 
  *   mdb.requestDone(); 
  * DB和DBCollection是绝对线程安全的 
  * @author wujintao 
  */  
 public class MongoUtil{  
       
     private static Mongo mongo;  
     private static DBCollection coll;  
     private static Log log = LogFactory.getLog(MongoUtil.class);  
     private static DB db;  
       
     static{  
         try {  
               MongoOptions options = new MongoOptions();  
                       options.autoConnectRetry = true;  
                       options.connectionsPerHost = 1000;  
                       options.maxWaitTime = 5000;  
                       options.socketTimeout = 0;  
                       options.connectTimeout = 15000;  
                       options.threadsAllowedToBlockForConnectionMultiplier = 5000;  
             //事实上，Mongo实例代表了一个数据库连接池，即使在多线程的环境中，一个Mongo实例对我们来说已经足够了  
             mongo = new Mongo(new ServerAddress(DBMongoConfig.getHost(),DBMongoConfig.getPort()),options);  
             //mongo = new Mongo(DBMongoConfig.getHost(),DBMongoConfig.getPort());  
             // or, to connect to a replica set, supply a seed list of members  
             // Mongo m = new Mongo(Arrays.asList(new ServerAddress("localhost",  
             // 27017),  
             // new ServerAddress("localhost", 27018),  
             // new ServerAddress("localhost", 27019)));  
   
             // 注意Mongo已经实现了连接池，并且是线程安全的。  
             // 大部分用户使用mongodb都在安全内网下，但如果将mongodb设为安全验证模式，就需要在客户端提供用户名和密码：  
             // boolean auth = db.authenticate(myUserName, myPassword);  
         } catch (UnknownHostException e) {  
             log.info("get mongo instance failed");  
         }  
     }  
       
     public static DB getDB(){  
         if(db==null){  
             db = mongo.getDB(DBMongoConfig.getDbname());  
         }  
         return db;  
     }  
       
       
     public static Mongo getMong(){  
         return mongo;  
     }  
       
     public static DBCollection getColl(String collname){  
         return getDB().getCollection(collname);  
     }  
       
 }  