`
eric_hwp
  • 浏览: 125970 次
  • 性别: Icon_minigender_1
  • 来自: 杭州
社区版块
存档分类
最新评论

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

 
阅读更多

网上转载：分享一下我经常用到的自己写的mongo用法示例

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

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

 

分享到：
| 在恰当的地方使用MongoDB的WriteConcern.S ...
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    pymongo连接mongodb数据库以及增删改差相关操作

    pymongo连接mongodb数据库以及增删改差相关操作

    利用C#(winform)实现mongodb的增删改

    本篇文章将深入探讨如何使用C#和WinForm来实现MongoDB的增删改操作。 首先，我们需要在C#项目中引入MongoDB的驱动程序。MongoDB官方提供了`MongoDB.Driver`库，可以方便地与MongoDB进行通信。通过NuGet包管理器安装...

    MongoDB GridFS方式增删改图片代码

    网站大量图片存储需要用到Mongodb，本代码中以图片上传、图片更新、图片删除为例子，展示了以GridFS方式对文件进行存取。

    基于Servlet写的学生管理系统，前端是Layuimini，数据库采用MongoDB，实现增删改，模糊查询，分页查询的功能

    基于node.js、vue、mongodb等技术构建的web系统，界面美观，功能齐全，适合用作毕业设计、课程设计作业等，项目均经过测试，可快速部署运行！ 基于node.js、vue、mongodb等技术构建的web系统，界面美观，功能齐全，...

    C# to MongoDB 增删改通用demo

    这个“C# to MongoDB 增删改通用demo”应该涵盖了这些基本操作，通过学习和实践，你可以更好地理解如何在 C# 应用程序中与 MongoDB 进行交互，实现数据的存储和检索。这是一个很好的起点，进一步深入可以涉及更复杂...

    MongoDB高级查询用法大全

    MongoDB 高级查询用法大全 MongoDB 作为一个 NoSQL 数据库，提供了多种高级查询方式，以下是 MongoDB 高级查询用法大全： ...这些高级查询用法大全可以帮助开发者更好地使用 MongoDB 实现复杂的数据查询。

    Thinkphp使用mongodb数据库实现多条件查询方法

    在Thinkphp中实现多条件查询时，可以使用框架提供的查询构建器（Query Builder），但是当涉及到MongoDB的复合查询时，比如需要使用AND和OR逻辑运算符进行多条件筛选，官方文档中提供的方法可能不足以满足需求。...

    MongoDB基本查询.pdf

    本篇资料主要涵盖了MongoDB的基本查询操作，包括查询数据、格式化输出、筛选特定文档以及使用比较运算符进行查询。 首先，MongoDB 中用于查询数据的核心命令是 `find`，正如题目中所提及的，其基本语法格式为 `db....

    MongoDB基本操作指南

    MongoDB的查询语法简单直观，基于JSON，易于理解和使用。它支持多种查询操作，如范围查询、正则表达式查询和对子文档属性的查询。此外，MongoDB还提供了更新操作符，可以实现在服务器端的即时更新，减少客户端和...

    nodejs 操作mongodb，插查删改

    标题中的“nodejs操作mongodb，插查删改”指的是使用Node.js这门JavaScript后端运行环境来与MongoDB数据库进行交互，实现数据的增、删、查、改四大基本操作。MongoDB是一种流行的NoSQL数据库，它以JSON格式存储数据...

    MongoDB MapReduce分享.ppt

    在这个“MongoDB MapReduce 分享”中，我们将深入探讨 MapReduce 在 MongoDB 中的应用及其核心概念。 MapReduce 包含两个主要函数：Map 和 Reduce。Map 阶段负责将输入数据分解成小块，然后对每一块应用一个函数，...

    Mongodb增加、删除和查询操作

    MongoDB还支持复杂的查询操作，如聚合框架（Aggregation Framework），它允许我们进行更高级的数据处理，如分组、过滤、排序等。 ### 其他操作 除了增加、删除和查询，MongoDB还提供了更新操作，如`updateOne()`和...

    使用C#访问MongoDB实现简单增删改查

    本教程将详细介绍如何使用C#访问MongoDB，实现基本的增删改查操作。 首先，我们需要在C#项目中引入MongoDB的驱动程序。MongoDB官方提供了`MongoDB.Driver`库，可以通过NuGet包管理器安装。在Visual Studio中，右键...

    掌握MongoDB：NoSQL数据库基础与高级特性教程.rar

    目录 什么是 MongoDB MongoDB 简介 MongoDB 特点 安装与配置 安装 MongoDB 启动与配置 MongoDB 基本操作 数据库和集合 文档操作 查询操作 基本查询 高级查询 ...使用 MongoDB 实现简单...使用 MongoDB 实现简单的博客系统

    13、MongoDB分片集群&高级集群架构详解-ev.rar

    13、MongoDB分片集群&高级集群架构详解_ev.rar13、MongoDB分片集群&高级集群架构详解_ev.rar13、MongoDB分片集群&高级集群架构详解_ev.rar13、MongoDB分片集群&高级集群架构详解_ev.rar13、MongoDB分片集群&高级集群...

    mongodb 数据库基本操作.doc

    ### MongoDB数据库基本操作详解 #### 一、连接MongoDB数据库 MongoDB是一个广泛使用的开源文档数据库，支持多种编程语言。为了能够与MongoDB交互并执行各种数据库操作，首先需要通过官方提供的驱动程序或其他第三...

    mongodb基本增删改查代码

    查询数据是MongoDB中最常见的操作，使用`find()`方法。你可以传递一个过滤器对象来指定查询条件。例如： ```javascript // 查询所有用户 var allUsers = db.users.find(); // 查询年龄大于30的用户 var adults = ...

    mongodb-基础知识和高级知识

    3. 查询语言：MongoDB提供了MQL（MongoDB查询语言），支持丰富的查询操作，包括基本的字段匹配、条件查询，以及更复杂的聚合操作。 4. CRUD操作：创建（Create）、读取（Read）、更新（Update）和删除（Delete）是...

Magicbox
Global site tag (gtag.js) - Google Analytics