MongoDB入门必读(概念与实战并重)

MongoDB入门必读(概念与实战并重)

1、概述

　　MongoDB是一个基于分布式文件存储的数据库开源项目。由C++语言编写。旨在为WEB应用提供可护展的高性能数据存储解决方案。

　　MongoDB是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。他支持的数据结构很是松散，是相似json的bjson格式，所以能够存储比较复杂的数据类型。Mongo最大的特色是他支持的查询语言很是强大，其语法有点相似于面向对象的查询语言，几乎能够实现相似关系数据库单表查询的绝大部分功能，并且还支持对数据创建索引。

Mongo主要解决的是海量数据的访问效率问题，根据官方的文档，当数据量达到50GB以上的时候，Mongo的数据库访问速度是MySQL的10倍以上。Mongo的并发读写效率不是特别出色，根据官方提供的性能测试代表，大约每秒能够处理0.5万－1.5次读写请求。

由于Mongo主要是支持海量数据存储的，因此Mongo还自带了一个出色的分布式文件系统GridFS，能够支持海量的数据存储，但我也看到有些评论认为GridFS性能不佳，有待验证。

最后因为Mongo能够支持复杂的数据结构， 并且带有强大的数据查询功能，所以很是受到欢迎，不少项目都考虑用MongoDB来替代MySQL来实现不是特别复杂的Web应用，比方说why we migrated from MySQL to MongoDB就是一个真实的从MySQL迁移到MongoDB的案例，因为数据量实在太大，因此迁移到了Mongo上面，数据查询的速度获得了很是显著 的提高。

MongoDB也有一个ruby的项目MongoMapper，是模仿Merb的DataMapper编写的MongoDB的接口，使用起来很是简单，几乎和DataMapper如出一辙，功能很是强大易用。

　　总结起来，monggDB的特色是高性能、易部署、易使用，存储数据很是方便。主要功能特性有：

　　*面向集合存储，易存储对象类型的数据。
*模式自由。
*支持动态查询。
*支持彻底索引，包含内部对象。
*支持查询。
*支持复制和故障恢复。
*使用高效的二进制数据存储，包括大型对象（如视频等）。
*自动处理碎片，以支持云计算层次的扩展性
*支持RUBY，PYTHON，JAVA，C++，PHP等多种语言。
*文件存储格式为BSON（一种JSON的扩展）
*可经过网络访问

　　所谓“面向集合”（Collenction-Orented），意思是数据被分组存储在数据集中，被称为一个集合（Collenction)。 每一个集合在数据库中都有一个惟一的标识名，而且能够包含无限数目的文档。集合的概念相似关系型数据库（RDBMS）里的表（table），不一样的是它不需 要定义任何模式（schema)。
模式自由（schema-free)，意味着对于存储在mongodb数据库中的文件，咱们不须要知道它的任何结构定义。若是须要的话，你彻底能够把不一样结构的文件存储在同一个数据库里。
存储在集合中的文档，被存储为键-值对的形式。键用于惟一标识一个文档，为字符串类型，而值则能够是各中复杂的文件类型。咱们称这种存储形式为BSON（Binary Serialized dOcument Format）。

　　推荐阅读：

　　Ubuntu 13.04下安装MongoDB2.4.3

　　如何在MongoDB中创建新数据库和集合

MongoDB的优势
高性能，速度很是快（若是你的内存足够的话）
没有固定的表结构，不用为了修改表结构而进行数据迁移
查询语言简单，容易上手
使用Sharding实现水平扩展
部署方便 使用MongoDB，你得记住如下几点：
MongoDB 假设你有大磁盘空间
MongoDB 假设你的内存也足够大于放下你的热数据
MongoDB 假设你是部署在64位系统上的（32位有2G的限制，试用还能够）
MongoDB 假设你的系统是little-endian的
MongoDB 假设你有多台机器（并不专一于单机可靠性）
MongoDB 假设你但愿用安全换性能，同时容许你用性能换安全 MongoDB在下面领域不太擅长
不太稳定，特别是auto-sharding目前还有不少问题
不支持SQL，这意味着你不少经过SQL接口的工具再也不适用
持久化，MongoDB单机可靠性不太好，宕机可能丢失一段时间的数据
相关文档比较少，新功能都有这个问题
相关人才比较难找，这也是新功能的问题之一

　　2、安装

　　MongoDB服务端可运行在Linux、Windows或OS X平台，支持32位和64位应用，默认端口为27017。推荐运行在64位平台，由于MongoDB

　　在32位模式运行时支持的最大文件尺寸为2GB。MongoDB把数据存储在文件中（默认路径为：/data/db），为提升效率使用内存映射文件进行管理。

　　（一）Linux/OS X下:
1 创建数据目录
mkdir -p /data/db
2 下载压缩包
curl -O
3 解压缩文件
tar xzf mongodb-linux-i386-latest.tgz
4 启动服务
bin/mongod run &
5 使用自带客户端链接
/bin/mongo
6 测试
db.foo.save( { a : 1 } )
db.foo.findOne()

　　（二）windows下：

　　1 创建数据目录c:\data\db
2 下载压缩包，解压文件
3 启动服务
bin\mongod.exe run
4 自带客户端
bin\mongon.exe

　　在LINUX和WINDOWS系统下的使用大同小异，不一样的地方主要是默认的数据存储目录。LINUX类系统下存放在/data/db下，而WINDOWS

　　会存放在C:\data\db下。能够在启动时使用--dbpath参数指定存储目录并启动。如：bin\mongod.exe --dbpath d:\data\mongo

　　经常使用启动参数：
run 直接启动。例：./mongod run
--dbpath 指定特定存储目录启动，若目录不存在则建立。例：./mongod --dbpath /var/data/mongo
--port 指定端口启动。例：./mongod --port 12345

　　中止MONGO服务：
方法1：服务端中止，可以使用Ctrl+C
方法2：在客户端中止，可先链接客户端
./mongo
并使用命令
db.shutdownerver()
而后退出客户端
exit

　　3、mongoDB经常使用命令

　　一、与Mql对照

MySQL	MongoDB	说明
mysqld	mongod	服务器守护进程
mysql	mongo	客户端工具
mysqldump	mongodump	逻辑备份工具
mysql	mongorestore	逻辑恢复工具
db.repairDatabase()	修复数据库
mysqldump	mongoexport	数据导出工具
source	mongoimport	数据导入工具
grant * privileges on *.* to …	Db.addUser() 　　Db.auth()	新建用户并权限
show databases	show dbs	显示库列表
Show tables	Show collections	显示表列表
Show slave status	Rs.status	查询主从状态
Create table users(a int, b int)	db.createCollection("mycoll", {capped:true, 　　size:100000}) 另：可隐式建立表。	建立表
Create INDEX idxname ON users(name)	db.users.ensureIndex({name:1})	建立索引
Create INDEX idxname ON users(name,ts DESC)	db.users.ensureIndex({name:1,ts:-1})	建立索引
Insert into users values(1, 1)	db.users.insert({a:1, b:1})	插入记录
Select a, b from users	db.users.find({},{a:1, b:1})	查询表
Select * from users	db.users.find()	查询表
Select * from users where age=33	db.users.find({age:33})	条件查询
Select a, b from users where age=33	db.users.find({age:33},{a:1, b:1})	条件查询
select * from users where age<33	db.users.find({'age':{$lt:33}})	条件查询
select * from users where age>33 and age<=40	db.users.find({'age':{$gt:33,$lte:40}})	条件查询

　　

select * from users where a=1 and b='q'	db.users.find({a:1,b:'q'})	条件查询
select * from users where a=1 or b=2	db.users.find( { $or : [ { a : 1 } , { b : 2 } ] } )	条件查询
select * from users limit 1	db.users.findOne()	条件查询
select * from users where name like "%Joe%"	db.users.find({name:/Joe/})	模糊查询
select * from users where name like "Joe%"	db.users.find({name:/^Joe/})	模糊查询
select count(1) from users	Dunt()	获取表记录数
select count(1) from users where age>30	db.users.find({age: {'$gt': 30}}unt()	获取表记录数
select DISTINCT last_name from users	db.users.distinct('last_name')	去掉重复值
select * from users ORDER BY name	db.users.find().sort({name:-1})	排序
select * from users ORDER BY name DESC	db.users.find().sort({name:-1})	排序
EXPLAIN select * from users where z=3	db.users.find({z:3}).explain()	获取存储路径
update users set a=1 where b='q'	db.users.update({b:'q'}, {$set:{a:1}}, false, true)	更新记录
update users set a=a+2 where b='q'	db.users.update({b:'q'}, {$inc:{a:2}}, false, true)	更新记录
delete from users where z="abc"	db.users.remove({z:'abc'})	删除记录
db. users.remove()	删除全部的记录
drop database IF EXISTS test;	use test 　　db.dropDatabase()	删除数据库
drop table IF EXISTS test;	db.mytable.drop()	删除表/collection
db.addUser(‘test’, ’test’)	添加用户 　　readOnly-->false
db.addUser(‘test’, ’test’, true)	添加用户 　　readOnly-->true
db.addUser("test","test222")	更改密码
db.system.users.remove({user:"test"}) 　　或者db.removeUser('test')	删除用户

　　

use admin	超级用户
db.auth(‘test’, ‘test’)	用户受权
db.system.users.find()	查看用户列表
show users	查看全部用户
db.printCollectionStats()	查看各collection的状态
db.printReplicationInfo()	查看主从复制状态
show profile	查看profiling
pyDatabase('mail_addr','mail_addr_tmp')	拷贝数据库
db.users.dataSize()	查看collection数据的大小
db. users.totalIndexSize()	查询索引的大小

　　二、shell数据操做实战

插入数据到集合

　　下面咱们来创建一个test的集合并写入一些数据. 创建两个对象, j 和 t , 并保存到集合中去.
在例子里 ‘>’ 来表示是 shell 输入提示符

　　> j = { name : "mongo" };{"name" : "mongo"}> t = { x : 3 };{ "x" : 3 }> db.things.save(j);> db.things.save(t);> db.things.find();{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}>

　　有几点须要注意下 :

不须要预先创建一个集合. 在第一次插入数据时候会自动创建.
在例子其实能够存储任何结构的数据, 固然在实际应用咱们存储的仍是相同元素的集合. 这个特性其实能够在应用里很灵活, 你不须要相似alter table 来修改你的数据结构
每次插入数据时候对象都会有一个ID, 名字叫 _id.
当你运行不一样的例子, 你的对象ID值都是不一样的.

　　下面再加点数据:

　　> for( var i = 1; i < 10; i++ ) db.things.save( { x:4, j:i } ); > db.things.find();{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}

　　请注意下, 这里循环次数是10, 可是只显示到8, 还有2条数据没有显示.

　　若是想继续查询下面的数据只须要使用 it 命令, 就会继续下面的数据:

　　{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}

　　继续

　　> it{"x" : 4 , "j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}{"x" : 4 , "j" : 10 , "_id" : ObjectId("497cf87151712cf7758fbdc6")}

　　从技术上讲 find() 返回一个游标对象. 但在上面的例子里, 并无拿到一个游标的变量. 因此 shell 自动遍历游标, 返回一个初始化的set, 并容许咱们继续用 it 迭代输出.
固然咱们也能够直接用游标来输出, 不过这个是下一部分的内容了.

查询数据

　　在没有深刻查询以前, 咱们先看看怎么从一个查询中返回一个游标对象. 能够简单的经过 find() 来查询, 他返回一个任意结构的集合. 若是实现特定的查询稍后讲解.
实现上面一样的查询, 而后经过 while 来输出:

　　> var cursor = db.things.find();> while (cursor.hasNext()) { print(tojson(cursor.next())); }{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}{"x" : 4 , "j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}>

　　上面的例子显示了游标风格的迭代输出. hasNext() 函数告诉咱们是否还有数据, 若是有则能够调用 next() 函数. 这里咱们也用了自带的 tojson() 方法返回一个标准的 JSON 格式数据.

　　当咱们使用的是 JavaScript shell, 能够用到JS的特性, forEach 就能够输出游标了. 下面的例子就是使用 forEach() 来循环输出:

　　forEach() 必须定义一个函数供每一个游标元素调用.

　　> db.things.find().forEach( function(x) { print(tojson(x));});{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}{"x" : 4 , "j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}>

　　在 mongo shell 里, 咱们也能够把游标看成数组来用 :

　　> var cursor = db.things.find();> print (tojson(cursor[4]));{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}

　　使用游标时候请注意占用内存的问题, 特别是很大的游标对象, 有可能会内存溢出. 因此应该用迭代的方式来输出.
下面的示例则是把游标转换成真实的数组类型:

　　> var arr = db.things.find().toArray();> arr[5];{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}

　　请注意这些特性只是在 mongo shell 里使用, 而不是全部的其余应用程序驱动都支持.

　　MongoDB 游标对象不是没有快照 – 若是有其余用户在集合里第一次或者最后一次调用 next(), 你能够得不到游标里的数据. 因此要明确的锁定你要查询的游标.

指定条件的查询

　　到这里咱们已经知道怎么从游标里实现一个查询并返回数据对象, 下面就来看看怎么根据指定的条件来查询.

　　下面的示例就是说明如何执行一个相似SQL的查询, 并演示了怎么在 MongoDB 里实现. 这是在 MongoDB shell 里查询, 固然你也能够用其余的应用驱动或者语言来实现:

　　SELECT * FROM things WHERE name="mongo"

　　>db.things.find({name:"mongo"}).forEach(function(x) { print(tojson(x));});{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}>SELECT * FROM things WHERE x=4> db.things.find({x:4}).forEach(function(x) { print(tojson(x));});{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}{"x" : 4 , "j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}{"x" : 4 , "j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}{"x" : 4 , "j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}{"x" : 4 , "j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}{"x" : 4 , "j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}{"x" : 4 , "j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}{"x" : 4 , "j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}{"x" : 4 , "j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}>

　　查询条件是 { a:A, b:B, … } 相似 “where a==A and b==B and …”, 更多的查询方式能够参考 Mongo 开发教程部分.

　　上面显示的是全部的元素, 固然咱们也能够返回特定的元素, 相似于返回表里某字段的值, 只须要在 find({x:4}) 里指定元素的名字, 好比 j:

　　SELECT j FROM things WHERE x=4> db.things.find({x:4}, {j:true}).forEach(function(x) { print(tojson(x));});{"j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}{"j" : 2 , "_id" : ObjectId("497cf87151712cf7758fbdbe")}{"j" : 3 , "_id" : ObjectId("497cf87151712cf7758fbdbf")}{"j" : 4 , "_id" : ObjectId("497cf87151712cf7758fbdc0")}{"j" : 5 , "_id" : ObjectId("497cf87151712cf7758fbdc1")}{"j" : 6 , "_id" : ObjectId("497cf87151712cf7758fbdc2")}{"j" : 7 , "_id" : ObjectId("497cf87151712cf7758fbdc3")}{"j" : 8 , "_id" : ObjectId("497cf87151712cf7758fbdc4")}{"j" : 9 , "_id" : ObjectId("497cf87151712cf7758fbdc5")}>

　　请注意 “_id” 元素会一直被返回.

findOne()

　　为了方便, mongo shell (其余驱动) 避免游标的可能带来的开销, 提供一个findOne() 函数. 这个函数和 find() 参数同样, 不过他返回游标里第一条数据, 或者返回 null 空数据库.

　　做为一个例子, name==’mongo’ 能够用不少方法来实现, 能够用 next() 来循环游标(须要校验是否为null), 或者当作数组返回第一个元素.

　　可是用 findOne() 方法则更简单和高效:

　　> var mongo = db.things.findOne({name:"mongo"});> print(tojson(mongo));{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}>

　　findOne 方法更跟 find({name:”mongo”}).limit(1) 同样.

limit() 查询

　　你能够须要限制结果集的长度, 能够调用 limit 方法.

　　这是强烈推荐高性能的缘由, 经过限制条数来减小网络传输, 例如:

　　> db.things.find().limit(3);in cursor for : DBQuery: example.things ->{"name" : "mongo" , "_id" : ObjectId("497cf60751712cf7758fbdbb")}{"x" : 3 , "_id" : ObjectId("497cf61651712cf7758fbdbc")}{"x" : 4 , "j" : 1 , "_id" : ObjectId("497cf87151712cf7758fbdbd")}>

更多帮助

　　除非了通常的 help 以外, 你还能够查询 help 数据库和db.whatever 来查询具体的说明.

　　这篇写得经常使用命令也不错

　　4、与java结合

　　使用JAVA语言操做MONGODB很是简单，只要将驱动文件加入到CLASSPATH中就可使用。

　　

　　junit-4.11和hamcrest-core-1.3是junit4依赖包

　　mongo-java-driver-2.9.3为mongodb的java驱动包

　　实战：

　　import com.mongodb.Mongo;
import com.mongodb.DBCollection;
import com.mongodb.BasicDBObject;
import com.mongodb.DBObject;
import com.mongodb.DBCursor;
import com.mongodb.MongoAdmin; 

　　一、得到链接

　　Mongo db = new Mongo("mydb");
Mongo db = new Mongo("localhost", "mydb");
Mongo db = new Mongo("localhost", 27017, "mydb");

　　查看mongoDB数据库列表
Mongo m = new Mongo();
for (String s : m.getDatabaseNames()) {
System.out.println(s);
}

　　删除一个数据库
Mongo m = new Mongo();
m.dropDatabase("myDatabaseName");

　　2 安全验证（非必选）
MongoDB服务能够在安全模式运行，此时任何客户端要链接数据库时需使用用户名和密码。在JAVA中可以使用以下方法链接：

　　boolean auth = db.authenticate(userName, password);

　　若是用户名密码验证经过，返回值为true，不然为false

　　3 获取集合列表
每一个数据库都存在零个或多个集合，须要时你能够得到他们的列表：

　　Set<String> colls = db.getCollectionNames();
for(String s : colls){
System.out.println(s);
}

　　4 得到一个集合
要得到某个特定集合，你能够指定集合的名字，并使用getCollection()方法：

　　DBCollection coll = db.getCollection("testCollection");

　　当你获取了这个集合对象，你就能够对数据进行增删查改之类的操做。

　　查看一个集合的索引

　　List<DBObject> list = coll.getIndexInfo();
for (DBObject o : list) {
System.out.println(o);
}

　　5 插入文档

　　默认ID
当保存的对象没有设置ID时，mongoDB会默认给该条记录设置一个ID（"_id"）。
固然你也能够设置本身指定的ID，如：(在mongoDB中执行用db.users.save({_id:1,name:'bruce'});)

　　当你得到了一个集合对象，你就能够把文档插入到这个对象中。例如，存在一个JSON式的小文档：
{
"name" : "MongoDB",
"type" : "database",
"count" : 1,
"info" : {
x : 203,
y : 102
}
}
请注意，这个文档包含一个内部文档。咱们可使用BasicDBObject类来建立这个文档，而且使用insert()方法方便地将它插入到集

　　合中。

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

　　批量插入
List datas = new ArrayList();
for (int i=0; i < 100; i++) {
BasicDBObject bo = new BasicDBObject();
bo.put("name", "bruce");
bo.append("age", i);
datas.add(bo);
}
coll.insert(datas);

　　6 使用findOne()查找集合中第一个文档
要查找咱们上一步插入的那个文档，能够简单地使用findOne()操做来获取集合中第一个文档。这个方法返回一个单一文档（这是相对于使用DBCursor的find()操做的返回），这对于只有一个文档或咱们刚插入第一个文档时颇有用，由于此时并不须要使用光标。

　　DBObject myDoc = coll.findOne();
System.out.println(myDoc);

　　返回相似：
{
"_id" : "ac907a1f5b9d5e4a233ed300" ,
"name" : "MongoDB" ,
"type" : 1 ,
"info" : {
"x" : 203 ,
"y" : 102} ,
"_ns" : "testCollection"
}

　　注意_id和_ns元素是由MongoDB自动加入你的文档。记住：MongoDB内部存储使用的元素名是以“_”作为开始。

　　7 加入多种文档
为了作更多有趣的查询试验，让咱们向集合中加入多种文档类型，象：
{
"i" : value
}
能够经过循环来实现

　　for(int i = 0; i < 100; i++){
coll.insert(new BasicDBObject().append("i", i));
}

　　注意咱们能够在一个集合中插入不一样类型的文档，这就是咱们所说的“模式自由”（schema-free）。

　　8 统计文档数量
使用getCount()方法

　　System.out.println(coll.getCount());

　　9 使用光标（cursor）来获取所有文档
为了获取集合中的全部文档，咱们可使用find()方法。这个方法返回一上DBCursor对象，来容许咱们将符合查询条件的文档迭代

　　出来。

　　DBCursor cur = coll.find();
while(cur.hasNext()){
System.out.println(cur.next());
}

　　10 在查询中获取单一文档
咱们能够建立一个查询，并传递给find()方法来获取集合中全部文档的一个子集。例如，咱们想要查询域名为"i"，而且值为71的文档：

　　BasicDBObject query = new BasicDBObject();
query.put("i", 71);
cur = coll.find(query);
while(cur.hasNext()){
System.out.println(cur.next());
}

　　类转换
当把一个类对象存到mongoDB后，从mongoDB取出来时使用setObjectClass()将其转换回原来的类。
public class Tweet implements DBObject {
/* ... */
}
Tweet myTweet = new Tweet();
myTweet.put("user", "bruce");
myTweet.put("message", "fun");
myTweet.put("date", new Date());
collection.insert(myTweet);
//转换
collection.setObjectClass(Tweet);
Tweet myTweet = (Tweet)collection.findOne();

　　11 使用条件查询获取集合

　　比较符
"$gt"： 大于
"$gte"：大于等于
"$lt"： 小于
"$lte"：小于等于
"$in"： 包含

　　例如，咱们想要查询全部i>50的文档：

　　BasicDBObject query = new BasicDBObject();
query.put("i", new BasicDBObject("$gt", 50));
cur = coll.find(query);
while(cur.hasNext()){
System.out.println(cur.next());
}

　　固然，咱们也能够作20 < i <= 30的查询

　　BasicDBObject query = new BasicDBObject();
query.put("i", new BasicDBObject("$gt", 20).append("$lte", 30));
cur = coll.find(query);
while(cur.hasNext()){
System.out.println(cur.next());

　　}

　　正则表达式
查询全部名字匹配 /joh?n/i 的记录
Pattern pattern = pile("joh?n", CASE_INSENSITIVE);
BasicDBObject query = new BasicDBObject("name", pattern);
DBCursor cursor = coll.find(query);

　　12 建立索引
MongoDB支持索引，并且很容易在集合上增长索引。要建立索引，只须要指定要加索引的属性，而且指定升序（1）或降序便可（-1）。

　　coll.createIndex(new BasicDBObject("i", 1));

　　13 获取索引列表

　　List<DBObject> list = coll.getIndexInfo();
for(DBObject o : list){
System.out.println(o);
}

　　14 MongoDB管理函数
管理函数在com.mongodb.MongoAdmin类中定义。
例A：获取数据库列表
MongoAdmin admin = new MongoAdmin();
for(String s : admin.getDatabaseNames()){
System.out.println(s);
}

　　例B：获取数据库对象
Mongo m = admin.getDB("mydb");

　　例C：删除数据库
admin.dropDatabase("mydb");

　　15 用DBObject存储JAVA对象
MongoDB for JAVA驱动中提供了用于向数据库中存储普通对象的接口DBObject
例如，存在一个须要存储的对象类Tweet
public class Tweet implements DBObject{
/*...*/
}
可使用以下代码：

　　Tweet myTweet = new Tweet();
myTweet.put("user", userId);
myTweet.put("message", message);
myTweet.put("date", new Date());

　　collection.insert(myTweet);

　　当一个文档从MongoDB中取出时，它会自动把文档转换成DBObject接口类型，要将它实例化为你的对象，需使用

　　DBCollection.setObjectClass()。
collection.setObjectClass(Tweet);
Tweet myTweet = (Tweet)collection.findOne();

　　16 JAVA驱动的并发性
JAVA的MongoDB驱动是线程安全的。若是你将它用在WEB服务中，能够建立它的一个单例，并在全部请求中使用它。

　　然而，若是你须要在一个会话（例如HTTP请求）中保证事务一致性，也许你会但愿在这个会话中对驱动使用同一个端口。这仅仅在

　　请求量很是大的环境中，例如你常常会读取刚写入的数据。
为了这一点，你须要使用以下代码：
Mongo m;
m.restartStart();

　　// code.........

　　m.requestDone(); 

　　源码下载地址

　　免费下载地址在

　　用户名与密码都是

　　具体下载目录在 /2013年资料/7月/9日/MongoDB入门必读(概念与实战并重)