mongodb总结、

初识Mongodb总结

您的评价: 收藏该经验

MongoDb 概述

MondoDb是什么

MongoD B是一个面向文档的数据库系统。使用C++编写，不支持SQL，但有自己功能强大的查询语法。MongoD B使用BSON 作为数据存储和传输的格式。BSON 是一种类似JSON的二进制序列化文档，支持嵌套对象和数组。MongoD B很像MySQL，document对应MySQL的row，collection对应MySQL的table。是当前NoSql数据库中比较热门的一种。它在许多场景下可用于替代传统的关系型数据库或键/值存储方式。

NoSQL与关系型数据库设计理念比较

关系型数据库中的表都是存储一些格式化的数据结构，每个元组字段的组成都一样，即使不是每个元组都需要所有的字段，但数据库会为每个元组分配所有的字段，这样的结构可以便于表与表之间进行连接等操作，但从另一个角度来说它也是关系型数据库性能瓶颈的一个因素。而非关系型数据库以键值对存储，它的结构不固定，每一个元组可以有不一样的字段，每个元组可以根据需要增加一些自己的键值对，这样就不会局限于固定的结构，可以减少一些时间和空间的开销。

特点高性能、易部署、易使用，存储数据非常方便。

1. 面向集合存储，易存储对象类型的数据。

2. 模式自由。

3. 支持动态查询。

4. 支持完全索引，包含内部对象。

5. 支持复制和故障恢复。

6. 使用高效的二进制数据存储，包括大型对象（如视频等）。

7. 自动处理碎片，以支持云计算层次的扩展性

8. 支持Python，PHP，Ruby，Java，C，C#，Javascript，Per l及C++语言的驱动程序。

9. 文件存储格式为BSON（一种JSON的扩展）。

10. 可通过网络访问。

功能

1. 面向集合的存储：适合存储对象及JSON形式的数据。

2. 动态查询：Mongo支持丰富的查询表达式。查询指令使用JSON形式的标记，可轻易查询文档中内嵌的对象及数组。

3. 完整的索引支持：包括文档内嵌对象及数组。Mongo的查询优化器会分析查询表达式，并生成一个高效的查询计划。

4. 查询监视：Mongo包含一个监视工具用于分析数据库操作的性能。

5. 复制及自动故障转移：Mongo数据库支持服务器之间的数据复制，支持主-从模式及服务器之间的相互复制。复制的

主要目标是提供冗余及自动故障转移。

6. 高效的传统存储方式：支持二进制数据及大型对象（如照片或图片）

7. 自动分片以支持云级别的伸缩性：自动分片功能支持水平的数据库集群，可动态添加额外的机器。

MongoDB设置访问权限、设置用户

MongoDB已经使用很长一段时间了，基于MongoDB的数据存储也一直没有使用到权限访问（MongoDB默认设置为无权限访问限制），今天特地花了一点时间研究了一下，研究成果如下：

注：研究成果基于Window s平台

MongoDB在本机安装部署好后

1. 输入命令：show dbs，你会发现它内置有两个数据库，一个名为admin，一个名为local。local好像没啥用，如果哪位在使用过程中发现了这个local表的用途，希望能够留言提醒，那我们就专心来说说admin表

2. 输入命令：use admin，你会发现该DB下包含了一个https://www.360docs.net/doc/a310522260.html,er表，呵呵，没错，这个表就等同于MsSql中的用户表，用来存放超级管理员的，那我们就往它里面添加一个超级管理员试试看

3. 输入命令：db.addUser('sa','sa')，这里我添加一个超级管理员用户，username为sa，passw ord也为sa，即然我们添加了超级管理员，那咱们就来测试下，看看咱们再次连接MongoDB需不需要提示输入用户名、密码，我们先退出来(ctrl+c)

4. 输入命令：use admin

5. 输入命令：show collections，查看该库下所有的表，你会发现，MongoDB并没有提示你输入用户名、密码，那就奇怪了，这是怎么回事呢？在文章最开始提到了，

MongoDB默认设置为无权限访问限制，即然这样，那我们就先把它设置成为需要权限访问限制，咱们再看看效果，怎么设置呢？

6. 在注册表中，找到MongoDB的节点，在它的ImgPath中，我们修改一下，加入-au th，如下所示：

"D:\Program Files\mongodb\bin\mongod"

-dbpath e:\w ork\data\mongodb\db -logpath e:\w ork\data\mongodb\log -au th-service

7. 输入命令：use admin

8. 输入命令：show collections，呵呵，我们发现无法查看该库下的表了，提示："$err" : "unauthorized db:admin lock type:-1

client:127.0.0.1"，很明显，提示没有权限，看来关键就在于这里，我们在启动MongoDB时，需要加上-au th参数，这样我们设置的权限才能生效，好，接下来我们使用刚刚之前设置的用户名、密码来访问

9. 输入命令：db.auth('sa','sa')，输出一个结果值为1，说明这个用户匹配上了，如果用户名、密码不对，会输入0

10. 输入命令：show collections，呵呵，结果出来了，到这里，权限设置还只讲到一多半，接着往下讲，我们先退出来(ctrl+c)

11. 输入命令：mongo TestDB，我们尝试连接一个新的库（无论这个库是否存在，如果不存在，往该库中添加数据，会默认创建该库），然后，我们想看看该库中的表

12. 输入命令：show collections，好家伙，没权限，我们输入上面创建的用户名、密码

13. 输入命令：db.auth('sa','sa')，输入结果0，用户不存在，这下有人可能就不明白了，刚刚前面才创建，怎么会不存在呢？原因在于：当我们单独访问MongoDB的数据库时，需要权限访问的情况下，用户名密码并非超级管理员，而是该库的https://www.360docs.net/doc/a310522260.html,er表中的用户，注意，我这里说的是单独访问的情况，什么是不单独访问的情况呢？接下来再讲，现在咋办，没权限，那我们就尝试给库的https://www.360docs.net/doc/a310522260.html,er表中添加用户

14. 输入命令：db.addUser('test','111111')，哇靠，仍然提示没有权限，这可咋办，新的数据库使用超级管理员也无法访问，创建用户也没有权限，呵呵，别急，即然设定了超级管理员用户，那它就一定有权限访问所有的库

15. 输入命令：use admin

16. 输入命令：db.auth('sa','sa')

17. 输入命令：use TestDB

18. 输入命令：show collections，哈哈，一路畅通无阻，我们发现可以利用超级管理员用户访问其它库了，呵呵，这个就是不单独访问的情况，不难发现，我们是先进入admin库，再转到其它库来的，admin相当于是一个最高级别官员所在区域，如果你是个地产商，想在地方弄个大工程做做，你想不经过那些高级官员就做，这是行不通的，你需要先去到他们那里，送点礼，再顺着下到地方，工程你就可以拿到手了，此言论仅为个人观点，不代表博客园；即然工程拿到手了，就要开始建了，那我们不至于每加块砖、添个瓦都得去和那帮高级官员打招呼吧，所以我们得让这个工程合法化，咱们得把相关的手续和证件弄齐全，不至于是违建

19. 输入命令：db.addUser('test','111111')，我们给TestDB库添加一个用户，以后每次访问该库，我都使用刚刚创建的这个用户，我们先退出（ctrl+c）

20. 输入命令：mongo TestDB

21. 输入命令：show collections，提示没有权限

22. 输入命令：db.auth('test','111111')，输出结果1，用户存在，验证成功

23. 输入命令：show collections，没再提示我没有权限，恭喜您，成功了

好累啊！一口气写完，呵呵

注：当需要使用权限才能访问MongoDB时，如果需要查看MongoDB中所有的库，我们只能通过超级管理员权限，输入命令show dbs来查看了。

MongoDB搭建和简单操作（windows环境）

昨天看到fish的MongoDB，但遇到不少问题，于是自己一步一步尝试，将遇到之问题和解决方法记录总结

首先感谢fish！昨天忘了放链接：https://www.360docs.net/doc/a310522260.html,/fish-li/archive/2011/06/26/2090800.htm l

再有就是快一年没更新博客了，不过本人天天打开博客园看各位的博文，就像公务员每天上班喝茶看报纸一样，习惯了。。。尽量以后每月出个两篇文章吧，本人这一年没写博客就干了一个活，https://www.360docs.net/doc/a310522260.html,，请大家赏析，前台使用m vc2.0，spar k 引擎，Entity Fr amewor k，当然还有j Query

这篇写完，这周再出个简单用C#操作MongoDB的增删改查，Demo将会以MVC+SPARK的方式出现，哎，为什么没几个人用spar k，这么好的东西，比什么r azor好多了，只是没有智能提示而已~

您可以在这个地址下载到MongoDB: https://www.360docs.net/doc/a310522260.html,/downloads

本人环境32位win7旗舰片，因此下载到mongodb-win32-i386-1.8.2

在下载页的下方官方有提供各种开发语言的驱动，本人C#，直接移位https://github.c om/samus/mongodb-cshar p下载即可

一，安装mongoDB

1，解压mongodb-win32-i386-1.8.2至E:\MyPr ogr am\mongodb-win32-i386-1.8.2（你可以按照自己的路径来，路径中最好不要有空格，要不然麻烦）

2，新建文件夹C:\DATA\DB，这是mongoDB的默认数据文件夹，你也可以在文件夹E:\MyPr ogr am\mongodb-win32-i 386-1.8.2新建一个文件夹data作为mongoDB的数据库文件存储目录

3，进入CMD，运行命令E:\MyProgr am\mongodb-win32-i386-1.8.2\bin\mongod.exe -dbpath E:\MyPr ogr am\m ongodb-win32-i386-1.8.2\data，OK，mongoDB已经安装成功并已经在运行中了，你将会看到如下：

此时是mongoDB的运行状态，你可以按Ctrl+C结束运行状态或者直接关掉CMD结束运行。

二，运行mongoDB时的错误与处理

完成安装后，结束掉所有CMD窗口，然后进行如下操作：

1，运行E:\MyPr ogram\mongodb-win32-i386-1.8.2\bin\mongo，可能会报错误：c ouldn't c onnect to server 127.

0.0.1 shell/mongo.js，原因是mongod.exe没有启动，

2，既然没启动，那咱就启动呗，运行E:\MyPr ogr am\mongodb-win32-i386-1.8.2\bin\mongod，可能会报错误：dbpa th (/data/db/) does not exist, ter m inating，看这样子，本人觉得还得在data文件夹下再建一个db文件夹啊，如此即新建一db文件夹，再运行mongod命令，结果提示一样，不知道怎么搞啦，咱google吧

找到文章http://www.m https://www.360docs.net/doc/a310522260.html,/display/DOCS/Starting+and+Stopping+Mongo

说“To start Mongo in default mode, where data will be stor ed in the /data/db dir ectory (or c:\data\db on Windows), and listening on port 27017”，哦，原来默认的文档路径在c:\data\db，啥也不说，直接按这个建文件夹，再次运行命令mongod，OK了，启动成功，这个命令窗口不能关闭，否则mongoDB就退出了

三，使用mongo命令

保持mongod命令窗口的运行状态，再新开一命令窗口

输入E:\MyProgr am\mongodb-win32-i386-1.8.2\bin\mongo，出现

MongoDB shell ver sion:1.8.2

connecting to:test

OK，连接成功。

1，show dbs 显示数据库列表

2，use N orthwind 进入Northwind数据库,大小写敏感

3，show collections 显示数据库中的集合

4，db 用于查看当前所在的数据库

5，db.Customer.c ount() 查看集合Customer的记录总数

6，db.Customer.findOne({"_id":"1"}) 查看Customer Id=1的记录

新增数据

1，use MyTest，这个数据库不存在，无所谓，mongo会创建，

MongoDB在使用前，并不要求您事先创建好相应的数据库，设计数据表结构！

在MongoDB中，没有【表】的概念，取而代之的是【集合】，也没有【数据记录】的概念，取而代之的是【文档】，我们可以把【文档】理解成一个【对象】，任意的对象，甚至可以有复杂的嵌套层次。

因此，我们不用再写代码从【数据表字段】到C#类的【属性，字段】的转换了，现在直接就可以读写整个对象了。

而且MongoDB不支持Join操作，所以，如果有【关联】操作，就需要你自己来处理

2，item={"Key":"1","text":"wokao","number":3}

3，db.table1.insert(item)，mongo将建立集合table1，并将item插入，完成了新增加数据库的工作

4，db.table1.find()显示table1中的数据，MongoDB的文档使用的是一种称为BSON格式的对象，与Javascript中的JS ON类似

5，额外的，输入item1={"Id":5,"str":"asdfasdf"}，再插入db.table1.insert(item1)，再用find()命令看，也插入成功了~，注意到结构和item不一样！但不建议这样做。

注意到：【每个文档有一个名为"_id" 的成员】，我可没有定义啊。

其实，MongoDB会为每个文档都创建这样一个文档成员，我们指定的"key", "id" 对于MongoDB来说：它们并不是【文档的主键】，MongoDB只认"_id"，你可以指定，但如果不指定，MongoDB就自动添加。

修改数据

1，var t=db.table1.findOne({"Id":5})，获取一条记录

2，t.str="wokao"

3，db.table1.update({"Id":5},t)

删除数据

db.table1.r emove({"Id":5})

查找数据

上面已经有find和findOne命令，即用于查询

db.table1.find()

MongoDB的查询条件中，并没有>, <, >= , <= 这些运算符，而是使用"$lt", "$lte", "$gt", "$gte"

新建表

db.MyTest.table2.save({})

删除表

db.table1.drop()或db.r unCommand({"drop","table1"})

删除数据库

db.runCommand({"dr opDatabase": 1})，此命令只能删除当前数据库

获取服务端状态信息

db.runCommand({"serverStatus" : 1})

java操作MongoDb

1package zcy;

3import java.io.*;

4import https://www.360docs.net/doc/a310522260.html,.*;

5import java.util.*;

6import com.mongodb.*;

7import com.mongodb.gridfs.*;

9publicclass AddData {

10publicstaticvoid main(String[] args) throws UnknownHostException,MongoException{ 11//建立数据库连接

12 Mongo m=new Mongo("127.0.0.1");

13//指定使用的数据库

14 DB db=m.getDB("Rental");

15//指定使用的数据集合

16 DBCollection coll=db.getCollection("HouseInfo");

17//添加房屋基本信息

18 BasicDBObject doc=new BasicDBObject();

19 doc.put("title","二七东立国际一楼精装小户家电齐全24栋—"); //消息标题

20 doc.put("date",new Date()); //发布日期

21 doc.put("seller", 0); //seller为0表示是业主，为1表示是经纪人

22 doc.put("contact","134********"); //联系方式

23 doc.put("regional","江岸二七路"); //区域

24 doc.put("district","东立国际二期"); //小区

25 doc.put("address","江岸区工农兵路与二七路交汇处"); //详细地址

26 doc.put("rent",1200); //租金

27 doc.put("class","1室1厅1卫"); //整套户型

28 doc.put("basicinfo","普通住宅，精装修，朝向南北(第1层，共19层)"); //基本情况

29 doc.put("config","床/热水器/洗衣机/空调/冰箱/电视机/宽带"); //配置

30 doc.put("area",42); //总面积

31 doc.put("credit",3); //信用等级

33//添加照片信息

34 ArrayList list=new ArrayList();

35 GridFS f=new GridFS(db);

36 File image=new File("/home/orisun/Rental/rental1.jpg");

37 GridFSFile infile;

38try{

39 infile=f.createFile(image);

40 infile.put("title","卧室");

41 infile.put("describe","这是卧室，照片上显示的实际中都有");

42 infile.save();

43 list.add(infile);

44 }catch(IOException e){

45 e.printStackTrace();

46 }

47 image=new File("/home/orisun/Rental/rental2.jpg");

48try{

49 infile=f.createFile(image);

50 infile.put("title","大厅");

51 infile.put("describe","这是大厅，照片上显示的实际中都有");

52 infile.save();

53 list.add(infile);

55 e.printStackTrace();

56 }

57 image=new File("/home/orisun/Rental/rental3.jpg");

58try{

59 infile=f.createFile(image);

60 infile.put("title","卫生间");

61 infile.put("describe","这是卫生间，照片上显示的实际中都有");

62 infile.save();

63 list.add(infile);

64 }catch(IOException e){

65 e.printStackTrace();

66 }

68 doc.put("photo", list);

69 coll.insert(doc);

70 }

71 }

mongoDB JAVA操作

6人收藏此文章, 我要收藏发表于9个月前, 已有1067次阅读共0个评论

类转换

当把一个类对象存到mongoDB后，从mongoDB取出来时使用setObj ectClass()将其转换回原来的类。public class Tweet implements DBObject {

/* ... */

}

Tweet myTweet = new Tweet();

m yTweet.put("user", "bruc e");

m yTweet.put("message", "fun");

m yTweet.put("date", new Date());

collection.insert(myTweet);

//转换

collection.setObj ectClass(Tweet);

Tweet myTweet = (Tweet)c ollection.findOne();

默认ID

当保存的对象没有设置ID时，mongoDB会默认给该条记录设置一个ID（"_id"）。

当然你也可以设置自己指定的ID，如：(在mongoDB中执行用https://www.360docs.net/doc/a310522260.html,ers.save({_id:1,name:'bruc e'});)

bo.put('_id', 1);

bo.put('name', 'bruc e');

collection.insert(bo);

权限

判断是否有mongoDB的访问权限，有就返回tr ue，否则返回false。boolean auth = db.authenticate(m yUserName, myPassword);

查看mongoDB数据库列表

Mongo m = new Mongo();

for (String s : m.getDatabaseNames()) {

System.out.println(s);

}

查看当前库下所有的表名，等于在mongoDB中执行show tables;

Set c olls = db.getCollectionNames();

for (String s : c olls) {

System.out.println(s);

}

查看一个表的索引

List list = coll.getIndexInfo();

for (DBObj ect o : list) {

System.out.println(o);

}

删除一个数据库

Mongo m = new Mongo();

m.dr opDatabase("m yDatabaseName");

建立mongoDB的链接

Mongo m = new Mongo("loc alhost", 27017);

DB db = m.getDB("m yDatabaseN ame"); //相当于库名DBCollection c oll = db.getCollection("m yUsersTable")；//相当于表名

#查询数据

查询第一条记录

DBObj ect fir stDoc = c oll.findOne();

findOne()返回一个记录，而find()返回的是DBCur sor游标对象。

查询全部数据

DBCur sor cur = coll.find();

while(c ur.hasNext()) {

System.out.println(cur.next());

}

查询记录数量

coll.find().c ount();

coll.find(new BasicDBObject("age", 26)).c ount();

设置条件查询

BasicDBObj ect c ondition = new Basic DBObject();

condition.put("name", "br uc e");

condition.put("age", 26);

coll.find(c ondition);

查询部分数据块

DBCur sor cur sor = c oll.find().skip(0).lim it(10);

while(c ursor.hasN ext()) {

System.out.println(cur sor.next());

}

比较查询(age > 50)

BasicDBObj ect c ondition = new Basic DBObject();

condition.put("age", new BasicDBObj ect("$gt", 50));

coll.find(c ondition);

比较符

"$gt"：大于

"$gte"：大于等于

"$lt"：小于

"$lte"：小于等于

"$in"：包含

//以下条件查询20

condition.put("age", new BasicDBObj ect("$gt", 20).append("$lte", 30));

#插入数据

批量插入

List datas = new ArrayList();

for (int i=0; i < 100; i++) {

BasicDBObj ect bo = new BasicDBObj ect();

bo.put("name", "bruc e");

bo.append("age", i);

datas.add(bo);

}

coll.insert(datas);

$exists

用来判断一个元素是否存在：

如：db.things.find( {a:{$exists:true}}); // 如果存在元素a,就返回true

$type

基于 bson type 来匹配一个元素的类型，像是按照类型ID 来匹配，不过我没找到bson 类型和id 对照表。

db.things.find({a:{$type:2}}); // matc hes if a is a string

正则表达式

查询所有名字匹配 /joh?n/i 的记录

Patter n patter n = Pattern.c ompile("joh?n", CASE_INSENSITIVE);

BasicDBObj ect query = new Basic DBObject("name", pattern);

DBCur sor cur sor = c oll.find(query);

01 mport java.util.regex.Pattern;

03 import com.mongodb.BasicDBObject;

04 import com.mongodb.DB;

05 import com.mongodb.DBCollection;

06 import com.mongodb.DBCursor;

07 import com.mongodb.DBObject;

08 import com.mongodb.Mongo;

10 /**

11 * @author duanzc

12 * @date:2010-12-23 下午05:34:24

13 * @version :1.0

14 * @类说明：

15 */

16 public class MyTest {

17 public static void main(String[] args) {

18 try {

19 Mongo conn = new Mongo("127.0.0.1"); // 创建数据库连接

21 DB local = conn.getDB("local"); // 得到数据库

23 boolean auth = local.authenticate("doc1", "110210121".toCharArray()); // 用户验证

25 if(auth){ // 如果用户名密码验证成功

26 System.out.println("成功.......");

27 DBCollection col =

local.getCollection("collor"); // 获得表

28 select(col);

29 }

31 } catch (Exception e) {

32 e.printStackTrace();

33 }

34 }

35 36 /** 查询 */

37 private static void select(DBCollection col) {

38 DBObject conditions = new BasicDBObject(); // 条件类

39 Integer[] num = {10,99};

41 // conditions.put("collor", "red"); // 等于

42 // conditions.put("size", new BasicDBObject("$gt", 5)); // gt(>), lt(<), gte(>=), lte(<=), in(包含), nin((不包含)

43 // conditions.put("size", new BasicDBObject("$gt", 5).append("$lt", 15)); // >5 and <15, （可以多个条件）

44 // conditions.put("num", new BasicDBObject("$in", num)); // 无效

45 // conditions.put("properties.skills", "java"); // 子查询：list

46 // conditions.put("properties.age", 23); // 子查询：map

47 // DBCursor ite = col.find().skip(1).limit(2); // 取范围

49 DBCursor ite = col.find(conditions); // 结果集（属性条件：无条件查询所有）

50 DBCursor ite_ = col.find(new BasicDBObject // 结果集（直接条件）

51 ("$where", "this.size==10")); //>, <, >=, <=, == 52

53 while(ite.hasNext()){

54 System.out.println(ite.next());

55 }

56 System.out.println("............");

58 // =========== 模糊查询：只能用正则 ============

59 Pattern john = https://www.360docs.net/doc/a310522260.html,pile("ed"); // 正则

60 BasicDBObject query = new BasicDBObject("collor", john); 61 DBCursor ite2 = col.find(query);

62 while(ite2.hasNext()){

63 System.out.println(ite2.next());

64 }

65 }

66 }

Mongodb 快速入门之使用Java 操作Mongodb

2011年06月20日00:00 it168网站原创作者：廖煜嵘/译编辑：董建伟评论：1条

【IT168 专稿】在上一篇文章中，我们学习了Mongodb 的安装和初步使用，在本文中，将学习如何使用Java 去编程实现对Mongodb 的操作。

HelloWorld 程序

学习任何程序的第一步，都是编写HelloWorld 程序，我们也不例外，看下如何通过Java 编写一个HelloWorld 的程序。首先，要通过Java 操作Mongodb ，必须先下载Mongodb 的Java 驱动程序，可以在这里下载。

新建立一个Java 工程，将下载的驱动程序放在库文件路径下，程序代码如下： package com.mkyong.core;

import https://www.360docs.net/doc/a310522260.html,.UnknownHostException;

import com.mongodb.BasicDBObject;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.Mongo;

import com.mongodb.MongoException;

/**

* Java + MongoDB Hello world Example

public class App {

public static void main(String[] args) {

try {

//实例化Mongo对象，连接27017端口

Mongo mongo = new Mongo("loca lhost", 27017);

//连接名为yourdb的数据库，假如数据库不存在的话，mongodb会自动建立

DB db = mongo.getDB("yourdb");

// Get collection from MongoDB, database named "yourDB"

//从Mongodb中获得名为yourColleection的数据集合，如果该数据集合不存在，Mongodb会为其新建立

DBCollection collection = db.getCollection("yourCollection");

// 使用BasicDBObject对象创建一个mongodb的document,并给予赋值。

BasicDBObject document = new BasicDBObject();

document.put("id", 1001);

document.put("msg", "hello world mongoDB in Java");

//将新建立的document保存到collection中去

collection.insert(document);

// 创建要查询的document

BasicDBObject searchQuery = new BasicDBObject();

searchQuery.put("id", 1001);

// 使用collection的find方法查找document

DBCursor cursor = collection.find(searchQuery);

//循环输出结果

while (cursor.hasNext()) {

System.out.println(cursor.next());

}

System.out.println("Done");

} catch (UnknownHostException e) {

e.printStackTrace();

} catch (MongoException e) {

e.printStackTrace();

}

最后，输出的结果为：

{ "_id" : { "$oid" : "4dbe5596dceace565d229dc3"} ,

"id" : 1001 , "msg" : "hello world mongoDB in Java"}

Done

在上面的例子中，演示了使用Java对Mongodb操作的重要方法和步骤，首先通过创建Mongodb对象，传入构造函数的参数是Mongodb的数据库所在地址和端口，然后使用

getDB方法获得要连接的数据库名，使用getCollection获得数据集合的名，然后通过新建立BasicDBObject对象去建立document,最后通过collection的insert方法，将建立的document保存到数据库中去。而collection的find方法，则是用来在数据库中查找document。

从Mongodb中获得collection数据集

在Mongodb中，可以通过如下方法获得数据库中的collection:

DBCollection collection = db.getCollection("yourCollection");

如果你不知道collection的名称，可以使用db.getCollectionNames()获得集合，然后再遍历，如下：DB db = mongo.getDB("yourdb");

Set collections = db.getCollectionNames();

for(String collectionName : collections){

System.out.println(collectionName);

}

完成的一个例子如下：

package com.mkyong.core;

import https://www.360docs.net/doc/a310522260.html,.UnknownHostException;

import java.util.Set;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.Mongo;

import com.mongodb.MongoException;

/**

* Java : Get collection from MongoDB

public class GetCollectionApp {

public static void main(String[] args) {

try {

Mongo mongo = new Mongo("localhost", 27017);

DB db = mongo.getDB("yourdb");

Set collections = db.getCollectionNames();

for (String collectionName : collections) {

System.out.println(collectionName);

}

DBCollection collection = db.getCollection("yourCollection");

System.out.println(collection.toString());

System.out.println("Done");

} catch (UnknownHostException e) {

e.printStackTrace();

} catch (MongoException e) {

e.printStackTrace();

}

Mongodb中如何插入数据

下面，讲解下如何使用4种方式，将JSON数据插入到Mongodb中去。首先我们准备JSON

格式的数据，如下：

{

"database" : "mkyongDB",

"table" : "hosting",

"detail" :

{

records : 99,

index : "vps_index1",

active : "true"

}

我们希望用不同的方式，通过JAVA代码向Mongodb插入以上格式的JSON数据第一种方法，是使用BasicDBObject，方法如下代码所示：BasicDBObject document = new BasicDBObject();

document.put("database", "mkyongDB");

document.put("table", "hosting");

BasicDBObject documentDetail = new BasicDBObject();

documentDetail.put("records", "99");

documentDetail.put("index", "vps_index1");

documentDetail.put("active", "true");

document.put("detail", documentDetail);

collection.insert(document);

第二种方法是使用BasicDBObjectBuilder对象，如下代码所示：

BasicDBObjectBuilder documentBuilder = BasicDBObjectBuilder.start()

.add("database", "mkyongDB")

.add("table", "hosting");

BasicDBObjectBuilder documentBuilderDetail = BasicDBObjectBuilder.start()

.add("records", "99")

.add("index", "vps_index1")

.add("active", "true");

documentBuilder.add("detail", documentBuilderDetail.get());

collection.insert(documentBuilder.get());

第三种方法是使用Map对象，代码如下：

Map documentMap =new HashMap();

documentMap.put("database", "mkyongDB");

documentMap.put("table", "hosting");

Map documentMapDetail =new HashMap();

documentMapDetail.put("records", "99");

documentMapDetail.put("index", "vps_index1");

documentMapDetail.put("active", "true");

documentMap.put("detail", documentMapDetail);

collection.insert(new BasicDBObject(documentMap));

第四种方法，也就是最简单的，即直接插入JSON格式数据

String json ="{'database' : 'mkyongDB','table' : 'hosting',"+

"'detail' : {'records' : 99, 'index' : 'vps_index1', 'active' : 'true'}}}";

DBObject dbObject =(DBObject)JSON.parse(json);

collection.insert(dbObject);

这里使用了JSON的parse方法，将解析后的JSON字符串转变为DBObject对象后再直接插入到collection中去。

完整的代码如下所示：

packagecom.mkyong.core;

https://www.360docs.net/doc/a310522260.html,.UnknownHostException;

importjava.util.HashMap;

importjava.util.Map;

importcom.mongodb.BasicDBObject;

importcom.mongodb.BasicDBObjectBuilder;

importcom.mongodb.DB;

importcom.mongodb.DBCollection;

importcom.mongodb.DBCursor;

importcom.mongodb.DBObject;

importcom.mongodb.Mongo;

importcom.mongodb.MongoException;

importcom.mongodb.util.JSON;

/**

* Java MongoDB : Insert a Document

publicclass InsertDocumentApp {

publicstaticvoid ma in(String[] args){

try{

Mongo mongo =new Mongo("localhost", 27017);

DB db = mongo.getDB("yourdb");

// get a single collection

DBCollection collection = db.getCollection("dummyColl");

// BasicDBObject example

System.out.println("BasicDBObject example...");

BasicDBObject document =new BasicDBObject();

document.put("database", "mkyongDB");

document.put("table", "hosting");

BasicDBObject documentDetail =new BasicDBObject();

documentDetail.put("records", "99");

documentDetail.put("index", "vps_index1");

documentDetail.put("active", "true");

document.put("detail", documentDetail);

collection.insert(document);

DBCursor cursorDoc = collection.find();

while(cursorDoc.hasNext()){

System.out.println(cursorDoc.next());

}

collection.remove(new BasicDBObject());

// BasicDBObjectBuilder example

System.out.println("BasicDBObjectBuilder example..."); BasicDBObjectBuilder documentBuilder = BasicDBObjectBuilder.start()

.add("database", "mkyongDB")

.add("table", "hosting");

BasicDBObjectBuilder documentBuilderDetail = BasicDBObjectBuilder.start() .add("records", "99")

.add("index", "vps_index1")

.add("active", "true");

documentBuilder.add("detail", documentBuilderDetail.get());

collection.insert(documentBuilder.get());

DBCursor cursorDocBuilder = collection.find();

while(cursorDocBuilder.hasNext()){

System.out.println(cursorDocBuilder.next());

}

collection.remove(new BasicDBObject());

// Map example

System.out.println("Map example...");

Map documentMap =new HashMap();

documentMap.put("database", "mkyongDB");

documentMap.put("table", "hosting");

Map documentMapDetail =new HashMap();

documentMapDetail.put("records", "99");

documentMapDetail.put("index", "vps_index1");

documentMapDetail.put("active", "true");

documentMap.put("detail", documentMapDetail);

collection.insert(new BasicDBObject(documentMap));

DBCursor cursorDocMap = collection.find();

while(cursorDocMap.hasNext()){

System.out.println(cursorDocMap.next());

}

collection.remove(new BasicDBObject());

// JSON parse example

System.out.println("JSON parse example...");

String json ="{'database' : 'mkyongDB','table' : 'hosting',"+

"'detail' : {'records' : 99, 'index' : 'vps_index1', 'active' : 'true'}}}"; DBObject dbObject =(DBObject)JSON.parse(json);

collection.insert(dbObject);

DBCursor cursorDocJSON = collection.find();

while(cursorDocJSON.hasNext()){

System.out.println(cursorDocJSON.next());

}

collection.remove(new BasicDBObject());

}catch(UnknownHostException e){

e.printStackTrace();

}catch(MongoException e){

e.printStackTrace();

}

更新Document

假设如下的JSON格式的数据已经保存到Mongodb中去了，现在要更新相关的数据。

{"_id" : {"$oid" : "x"} , "hosting" : "hostA" , "type" : "vps" , "clients" : 1000}

{"_id" : {"$oid" : "x"} , "hosting" : "hostB" , "type" : "dedicated server" , "clients" : 100}

{"_id" : {"$oid" : "x"} , "hosting" : "hostC" , "type" : "vps" , "clients" : 900}

假设现在要将hosting中值为hostB的进行更新，则可以使用如下的方法：

BasicDBObject newDocument =new BasicDBObject();

newDocument.put("hosting", "hostB");

newDocument.put("type", "shared host");

newDocument.put("clients", 111);

collection.update(new BasicDBObject().append("hosting", "hostB"), newDocument);

可以看到，这里依然使用了BasicDBObject对象，并为其赋值了新的值后，然后使用collection的update方法，即可更新该对象。

更新后的输出如下：

{"_id" : {"$oid" : "x"} , "hosting" : "hostA" , "type" : "vps" , "clients" : 1000}

{"_id" : {"$oid" : "x"} , "hosting" : "hostB" , "type" : "shared host" , "clients" : 111}

{"_id" : {"$oid" : "x"} , "hosting" : "hostC" , "type" : "vps" , "clients" : 900}

另外，还可以使用mongodb中的$inc修饰符号去对某个值进行更新，比如，要将hosting值为hostB的document的clients 的值得更新为199(即100+99=199)，可以这样：

BasicDBObject newDocument =new BasicDBObject().append("$inc",

new BasicDBObject().append("clients", 99));

collection.update(new BasicDBObject().append("hosting", "hostB"), newDocument);

则输出如下：

{"_id" : {"$oid" : "x"} , "hosting" : "hostA" , "type" : "vps" , "clients" : 1000}

{"_id" : {"$oid" : "x"} , "hosting" : "hostB" , "type" : "dedicated server" , "clients" : 199}

{"_id" : {"$oid" : "x"} , "hosting" : "hostC" , "type" : "vps" , "clients" : 900}

接下来，讲解$set修饰符的使用。比如要把hosting中值为hostA的document中的

type的值进行修改，则可以如下实现：

BasicDBObject newDocument3 =new BasicDBObject().append("$set",

new BasicDBObject().append("type", "dedicated server"));

collection.update(new BasicDBObject().append("hosting", "hostA"), newDocument3);

则输出如下，把type的值从vps改为dedicated server:

{"_id" : {"$oid" : "x"} , "hosting" : "hostB" , "type" : "dedicated server" , "clients" : 100}

{"_id" : {"$oid" : "x"} , "hosting" : "hostC" , "type" : "vps" , "clients" : 900}

{"_id" : {"$oid" : "x"} , "hosting" : "hostA" , "clients" : 1000 , "type" : "dedicated server"}

要注意的是，如果不使用$set的修饰符，而只是如下代码：

BasicDBObject newDocument3 =new BasicDBObject().append("type", "dedicated server");

collection.update(new BasicDBObject().append("hosting", "hostA"), newDocument3);

则会将所有的三个document的type类型都改为dedicated server了，因此要使用$set以更新特定的document的特定的值。

如果要更新多个document中相同的值，可以使用$multi，比如，要把所有vps为type的document,将它们的clients的值更新为888，可以如下实现：

BasicDBObject updateQuery =new BasicDBObject().append("$set",

new BasicDBObject().append("clients", "888"));

collection.update(new BasicDBObject().append("type", "vps"), updateQuery, false, true);

输出如下：

{"_id" : {"$oid" : "x"} , "hosting" : "hostA" , "clients" : "888" , "type" : "vps"}

{"_id" : {"$oid" : "x"} , "hosting" : "hostB" , "type" : "dedicated server" , "clients" : 100}

{"_id" : {"$oid" : "x"} , "hosting" : "hostC" , "clients" : "888" , "type" : "vps"}

最后，还是给出更新document的完整例子：

package com.liao;

import https://www.360docs.net/doc/a310522260.html,.UnknownHostException;

import com.mongodb.BasicDBObject;

import com.mongodb.DB;

import com.mongodb.DBCollection;

import com.mongodb.DBCursor;

import com.mongodb.Mongo;

import com.mongodb.MongoException;

publicclass UpdateDocumentApp {

publicstaticvoid printAllDocuments(DBCollection collection){

DBCursor cursor = collection.find();

while (cursor.hasNext()) {

System.out.println(cursor.next());

}

publicstaticvoid removeAllDocuments(DBCollection collection){

collection.remove(new BasicDBObject());

}

publicstaticvoid insertDummyDocuments(DBCollection collection){

BasicDBObject document = new BasicDBObject();

document.put("hosting", "hostA");

document.put("type", "vps");

document.put("clients", 1000);

BasicDBObject document2 = new BasicDBObject();

document2.put("hosting", "hostB");

document2.put("type", "dedicated server");

document2.put("clients", 100);

BasicDBObject document3 = new BasicDBObject();

document3.put("hosting", "hostC");

document3.put("type", "vps");

document3.put("clients", 900);

collection.insert(document);

collection.insert(document2);

collection.insert(document3);

}

publicstaticvoid ma in(String[] args) {

try {

Mongo mongo = new Mongo("localhost", 27017);

DB db = mongo.getDB("yourdb");

DBCollection collection = db.getCollection("dummyColl");

System.out.println("Testing 1...");

insertDummyDocuments(collection);

//find hosting = hostB, and update it with new document

BasicDBObject newDocument = new BasicDBObject();

newDocument.put("hosting", "hostB");

newDocument.put("type", "shared host");

newDocument.put("clients", 111);

collection.update(new BasicDBObject().append("hosting", "hostB"), newDocument); printAllDocuments(collection);

removeAllDocuments(collection);

System.out.println("Testing 2...");

insertDummyDocuments(collection);

BasicDBObject newDocument2 = new BasicDBObject().append("$inc",

new BasicDBObject().append("clients", 99));

collection.update(new BasicDBObject().append("hosting", "hostB"), newDocument2); printAllDocuments(collection);

removeAllDocuments(collection);

System.out.println("Testing 3...");

insertDummyDocuments(collection);

BasicDBObject newDocument3 = new BasicDBObject().append("$set",

new BasicDBObject().append("type", "dedicated server"));

collection.update(new BasicDBObject().append("hosting", "hostA"), newDocument3); printAllDocuments(collection);

removeAllDocuments(collection);

System.out.println("Testing 4...");

insertDummyDocuments(collection);

BasicDBObject updateQuery = new BasicDBObject().append("$set",

new BasicDBObject().append("clients", "888"));

collection.update(

new BasicDBObject().append("type", "vps"), updateQuery, false, true);