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

TestCase.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如下：

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

}