MongoDB基本用法（增刪改高階查詢）

阿新 • • 發佈：2018-12-24

部落格分類：

分享一下我經常用到的自己寫的mongo用法示例

該示例基於當前最新的mongo驅動，版本為mongo-2.10.1.jar,用junit寫的單元測試。

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 classTestCase{
       //DBCursor cursor = coll.find(condition).addOption(Bytes.QUERYOPTION_NOTIMEOUT);//設定遊標不要超時

	@Test
	/**
	 * 獲取所有資料庫例項
	 */
	publicvoidtestGetDBS(){
		List<String> dbnames = MongoUtil.getMong().getDatabaseNames();
		for 
 (String dbname : dbnames) {
			System.out.println("dbname:" + dbname);
		}
	}

	@Test
	/**
	 * 刪除資料庫
	 */
	publicvoiddropDatabase(){
		MongoUtil.getMong().dropDatabase("my_new_db");
	}

	@Test
	/**
	 * 查詢所有表名
	 */
	publicvoidgetAllCollections(){
		Set<String> colls = MongoUtil.getDB().getCollectionNames();
		for (String s : colls) {
			System.out.println(s);
		}
	}

	@Test
	publicvoiddropCollection(){
		MongoUtil.getColl("jellonwu").drop();
	}

	/**
	 * 新增一條記錄
	 */
	@Test
	publicvoidaddData(){
		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
	/**
	 * 建立索引
	 */
	publicvoidcreateIndex(){
		MongoUtil.getColl("wujintao").createIndex(new BasicDBObject("i", 1));
	}

	@Test
	/**
	 * 獲取索引資訊
	 */
	publicvoidgetIndexInfo(){
		List<DBObject> list = MongoUtil.getColl("hems_online").getIndexInfo();
		for (DBObject o : list) {
			System.out.println(o);
		}
	}

	@Test
	/**
	 * 新增多條記錄
	 */
	publicvoidaddMultiData(){
		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
	/**
	 * 查詢第一條記錄
	 */
	publicvoidfindOne(){
		DBObject myDoc = MongoUtil.getColl("wujintao").findOne();
		System.out.println(myDoc);
	}

	@Test
	/**
	 * 獲取表中所有記錄條數
	 */
	publicvoidcount(){
		System.out.println(MongoUtil.getColl("wujintao").getCount());
		System.out.println(MongoUtil.getColl("wujintao").count());
	}

	@Test
	/**
	 * 獲取查詢結果集的記錄數
	 */
	publicvoidgetCount(){
		DBObject query = new BasicDBObject("name", "a");
		long count = MongoUtil.getColl("wujintao").count(query);
		System.out.println(count);
	}

	@Test
	/**
	 * 查詢所有結果
	 */
	publicvoidgetAllDocuments(){
		DBCursor cursor = MongoUtil.getColl("wujintao").find();
		try {
			while (cursor.hasNext()) {
				System.out.println(cursor.next());
			}
		} finally {
			cursor.close();
		}
	}

	@Test
	/**
	 * 按照一個條件查詢
	 */
	publicvoidqueryByConditionOne(){
		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多條件查詢,區間查詢
	 */
	publicvoidqueryMulti(){
		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
	 */
	publicvoidqueryMulti2(){
		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"： 包含   
	 */
	publicvoidqueryMulti3(){
		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)
	 */
	publicvoidqueryMulti4(){
		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
	 */
	publicvoidqueryIn(){
		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
	 */
	publicvoidqueryOr(){
		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
	publicvoidcustomQueryField()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
	publicvoidmapReduce()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
    publicvoidGroupByManyField()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
	/**
	 * 分頁查詢   
	 */
	publicvoidpageQuery(){
		DBCursor cursor = MongoUtil.getColl("wujintao").find().skip(0)
				.limit(10);
		while (cursor.hasNext()) {
			System.out.println(cursor.next());
		}
	}

	/**
	 * 模糊查詢
	 */
	publicvoidlikeQuery(){
		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
	/**
	 * 條件刪除   
	 */
	publicvoiddelete(){
		BasicDBObject query = new BasicDBObject();
		query.put("name", "xxx");
		// 找到並且刪除，並返回刪除的物件
		DBObject removeObj = MongoUtil.getColl("wujintao").findAndRemove(query);
		System.out.println(removeObj);
	}

	@Test
	/**
	 * 更新
	 */
	publicvoidupdate(){
		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 classMongoUtil{
	
	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");
		}
	}
	
	publicstatic DB getDB(){
		if(db==null){
			db = mongo.getDB(DBMongoConfig.getDbname());
		}
		return db;
	}
	
	
	publicstatic Mongo getMong(){
		return mongo;
	}
	
	publicstatic DBCollection getColl(String collname){
		return getDB().getCollection(collname);
	}
	
}

MongoDB基本用法（增刪改高階查詢）

部落格分類：分享一下我經常用到的自己寫的mongo用法示例該示例基於當前最新的mongo驅動，版本為mongo-2.10.1.jar,用junit寫的單元測試。 TestCase.java package com.wujintao.mongo; i

MongoDB的基本操作（增刪改查）

目錄概念整理資料庫：一個MongoDB中可以建立多個數據庫。集合：MongoDB的文件組。文件：實際存放資料的地方。常見的操作資料庫（新增，刪除）集合（新增，編輯，刪除）文件（增刪改查）重點查詢文件新增文件（objectId）編輯文件（set為部分更新，括號裡

用java實現對MongoDB的基本操作（增刪改查）

準備工作：要想用java實現對MongoDB的增刪改查，首先需要下載mongo的java驅動，mongo-java-driver-3.2.2，下載地址:https://oss.sonatype.org/content/repositories/releases/org/m

Mongodb基本操作入門,增刪改查和索引

less multi zhang 一個 attribute var sin 第一個 base 主要進程 mongod.exe為啟動數據庫實例的進程。 mongo是一個與mongod進程進行交互的JavaScript shell進程，它提供了一些交互的接口函數用戶

mongodb 集合操作（增刪改查）

有變添加 port strong ner 速度遊標基礎 ror 1、插入：使用insert或save方法想目標集合插入一個文檔： db.person.insert({"name":"ryan","age":30}); 使用batchInser

MongoDB基本操作1增刪改查篇

ODB 終端方法 copy 文件中一定的 dir 過濾 man mongoDB邏輯存結構 MongoDB的邏輯只要由文檔(document) 集合(collection) 數據庫(database)三部分組成。其中文檔的是MongoDB核心概念，它是MongoDB邏輯

Mysql的基本操作（增刪改查）

it行業 delet HERE zha 不重復 incr sch table watermark 以下是MySQL最基本的增刪改查語句，創建索引，刪除索引，查看索引。數據庫裏表的關聯。很多IT工作者都必須要會的命令，也是IT行業面試最常考的知識點，由於是入門級基礎命令

mongoTemplate簡單用法（增刪改查）

分頁時查詢數量： 1 2 3 4

mongoDB-- 基本的操作增刪改查

1:增 use database_name //使用資料庫,沒有則建立，但是不是真正意義上的建立，裡面有資料才顯示 db.createCollection("emp") //建立集合也就是表 db.createCollection("emp",

C#中對資料庫的基本操作（增刪改以及呼叫儲存過程）

因為最近在寫web API的時候需要對資料庫操作，所以要用到ADO.NET，因為之前沒有接觸過.NET所以也是一邊上網查資料看C#書一邊寫，現在對這塊基礎的部分已經掌握了，現在寫下來只是想對自己前段時間的學習做個簡單的總結，也便於自己以後查閱（網上有很多類似的資源，大家可以

查詢資料庫歷史（增刪改查等）記錄

相信大家有想檢視對orcl的操作歷史記錄的時候，那麼大家就要了解v$sqlarea 這個表它記錄了所有使用者對資料庫操作的所有歷史記錄廢話不多說直接上sqlselect * from v$sqlarea t 查詢出來一些欄位以及資料，發現你要用到的沒有那麼多我們通常用到的

Sql server基本語句（增刪改查）

1增 1.1【插入單行】insert [into] <表名> (列名) values (列值)例：insert into Strdents (姓名,性別,出生日期) values ('

MyBatis從入門到精通(四)：MyBatis XML方式的基本用法之增刪改

最近在讀劉增輝老師所著的《MyBatis從入門到精通》一書，很有收穫，於是將自己學習的過程以部落格形式輸出，如有錯誤，歡迎指正，如幫助到你，不勝榮幸！ 1. insert用法 1.1 簡單的insert方法假如現在我們想新增一個使用者，該如何操作呢？首先，在介面SysUserMapper中新增如下方法。

MyBatis學習——第一篇（增刪改查實現）

1：MyBatis入門 1.1 Mybatis概述 MyBatis 是一款優秀的持久層（ORM）框架，它支援定製化 SQL、儲存過程以及高階對映。MyBatis 避免了幾乎所有的 JDBC 程式碼

SQL Server資料庫開發（3.SQL高階查詢）

一，巢狀子查詢降低SQL語句的複雜度，提高SQL語句的可讀性 --子查詢作為條件 (where) --查詢王五前面的同學 select * from StuInfo where stuid < (select stu

初級SQL第三章（sql的高階查詢）

——排序函式 over([分組子句] 排序語句[排序方式]) ——row_number() 行號 select row_number() over(order by score desc) as '排名', StuInfo.s

線性表操作（增刪改查清空）

頭插法建立連結串列程式碼 #include <stdio.h> #include <stdlib.h> #define OK 1 #define ERROR -1 typedef int Status; typedef int ElemTyp

MySQL - 最經典的命令列操作資料庫 + 表（增刪改查例項）

MySQL - 最經典的命令列操作資料庫 + 表（增刪改查例項）安裝 MySQL 請參考：MySQL 安裝 + 入門大全 + 常用命令合集增刪改查例項步驟：（1）登入 MySQL，建立新的資料庫，切換資料庫：（2）建立相對複雜的表，查看錶結構：

mysql常用語句、命令（增刪改查功能）

修改資料庫的字符集 mysql>use mydb mysql>alter database mydb character set utf8;建立資料庫指定資料庫的字符集 mysql>create database mydb char

MongoDB之Curd（增改查刪）常用命令

MongoDB常用命令： show dbs 命令可以顯示所有資料庫的列表 db 顯示當前資料庫物件或集合 use <database> 可以連線到一個指定的資料庫建立資料庫語法 use DATABASE_NAME 如果資料庫不

MongoDB基本用法（增刪改高階查詢）

相關推薦