MongoDB 从入门到精通

1，安装并启动数据库 
   
   从官网（www.mongodb.org/downloads）下载一个适合你平台的版本，我的系统是win7 64位的，下载文件也就10几M，将下载的文件解压放到任何目录，最好避免使用带空格和中文的目录，本机将其解压至C盘，并将文件夹改名为mongodb，这样也是为了后面输入目录更方便。 
   
   进入mongodb目录，我们发现有如下目录结构 
   |--mongodb 
       |-- bin 
            |-- mongo.exe 
|-- mongod.exe ........ 

所以整个mongodb是非常简单的，以上列的也是我们最常用的命令，其它暂时不解释。 
为了以后的操作方便，因此我们将当前的bin目录加入path，如果不会的可以百度Google。 
现在打开一个命令窗口，键入mongod，则窗口会提示数据库启动失败，如果你仔细看控制台打出的消息，有如下这么一行： 
dbpath (/data/db/) does not exist, terminating 
目录/data/db/是Linux下面的表示法，代表着数据库默认的数据文件目录，而上面的提示的意思是说数据库目录不存在，那么我们就在mongodb止录下手动建立一个目录db，当然此时屏幕上可能有些乱，这时可输入cls进行清屏操作。再输入命令：mongodb --dbpath c:/mongodb/db，此时窗口打出几行日志，然后处于等待状态了，那么就表示数据库启动成功了！当然这个窗口不能关闭。 


2，登录并操作数据库（Shell方式） 

2.1，连接 
打开命令窗口，键入mongo，如果系统提示：connecting to: test，表示连接成功。 

2.2，查看所有库 
    键入show dbs,则会显示出当前数据库中所有的数据库名称。在mongodb里面是不用 
去手动建立一个数据库的，你只要直接使用就好，如果不存在数据库引擎会帮我们 
创建他们。这一点与传统数据库相比有些不同。 

2.3，使用mydb 
键入use mydb，使用数据库mydb，当然 
mongodb会帮助我们自动创建他们，当然这个时候数据库还是空的，可以通过输入 
show dbs来确认这一点。 
   
   2.4，新增记录 
   输入：

db.user.save({name:'Rod',age:30})

   
   2.5，查看集合当中所有文档 
   db.user.find()可查看出当前库user集合中所有的文档，如下图所示： 
   { "_id" : ObjectId("4df2201ac905b4e2a5f555cb"), "name" : "Rod", "age" : 30 } 
   此时发现，在文档的前面多了一列"_id"，这是自动加进去的，不用管他。 
   
   2.6，删除记录 
   db.user.remove()将删除所有记录，db.user.remove({name:'Rod'})将删除指定记录 
   
   2.6，保存多条记录 
   输入：

for(var i=1;i<=20;i++) db.user.save({x:8,y:i})

，可以看出整个语法很像 
   JS，其实你正在使用的就是一个JavaScript Shell。此时可以输入db.user.find() 
   来查看所有记录。 
   
   2.7，迭代器的使用 
   我们再向集合中插入一条记录：db.user.save({x:'test'})，再次查看所有记录 
   db.user.find()，则发现只显示出了前20条记录。此时可以输入it（iteraor）来 
   查看余下的记录。 
   
   在mongodb里可以将cursor当成数组来使用，如下所示： 
 

var cursor = db.user.find(); // 将游标缓存起来
   printjson(cursor[4]); // 打印出第5条记录

   注意此种方式会将前N行全查出来，所以对性能有较大影响。 
   
   2.8，根据条件查询 
   现要查询出y大于10的所有记录： 
 

db.user.find({y:{$gt:10}});

   其中$gt的意思就是“大于”，当然读者可推出其他N种表达。 
   
   2.9，查询指定列 
  

db.user.find({x:8},{y:true});// 查询出x=8的所有记录的y列
       db.user.find({},{y:true}); // 查询出所有的Y列

   
   2.10，只查第一列 
   有的时候我们只需要第一行的值，如果自己编程实现显得有些麻烦，因此数据库为我们 
   提供了一个方法：db.user.findOne(); 
   
   2.11，限制最大记录从而提高性能 
   我们可以通过limit来限制查询的最大行数，如下： 
   db.user.find().limit(4); // 只显示出前四条 
   
   2.12，修改记录 
   将第一条x为3的记录修改为后面的值，db.user.update({x:4},{x:4,y:1}); 
   
   3，MongoDB 数据结构 
   
   从以上可以看出，每一个MongoDB包含了多个库（通过show dbs查看），这些库都是在第一次使用时自动创建的可以通过use   dbName来使用指定库。每一个库包含了多个集合，可以使用命令show collections 显示所有集合，所以我们在操作文档的时候要手动指定集合(db.user.find)，每个集合包含多份文档，也就是json对象。 
   
   
   4，利用java操作MongoDB 
   从官网下载java版本的驱动并将其加入classpath。 

   3.1，建立连接 

Mongo m = new Mongo(); // 连接本地的27017端口
   // or
   Mongo m = new Mongo( "localhost" ); // 默认端口27017
   // or
   Mongo m = new Mongo( "localhost" , 27017 ); // 指定主机与端口
   DB db = m.getDB( "mydb" ); // 取得指定的库

    
   3.2，用户认证（可选） 
   在登录数据库时，在数据库启动时可以指定是否需要认证（mongod --auth .....）， 
   此时连接时就需要用户名和密码（--serviceUser xx --servicePassword xx），如下： 
 

boolean auth = db.authenticate(myUserName, myPassword);

   
   3.3，得到指定库的所有集合 
   
 

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

   
   3.4，得到指定集合 
 

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

   
   3.5，插入文档 

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); // 保存

   3.6，查询集合中的第一份文档 
 

DBObject myDoc = coll.findOne();

   
   3.7，增加多份文档 

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

   
   3.8，统计集合中文档的条数 
  

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

   
   3.9，利用游标得到所有记录 

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

   

3.10，查询指定文档
  BasicDBObject query = new BasicDBObject();

  query.put("x", 8);
     cur = coll.find(query);

  while(cur.hasNext()) {
          System.out.println(cur.next());
     }

   
   有时个为了方便我们也可以写成这种形式： 
 

query.put("i", new BasicDBObject("$gt", 20).append("$lte", 30));
   // i.e. 20 < i <= 30

   3.11，创建一个索引 
 

coll.createIndex(new BasicDBObject("i", 1));
   // create index on "i", ascending

   3.12，查询集合中的索引列表 

List<DBObject> list = coll.getIndexInfo();

   
   3.13，得到所有的库名 
 

Mongo m = new Mongo();
   m.getDatabaseNames();

   
   3.14，删除一个库 
 

m.dropDatabase("my_new_db");

   
   
   
   4，MongoDB类型与java类型 
   
   4.1，自动成生主键 
 

ObjectId id = new ObjectId();
   ObjectId copy = new ObjectId(id);

   
   4.2，正则表达式的运用 
 

Pattern john = Pattern.compile("joh?n", CASE_INSENSITIVE);
      BasicDBObject query = new BasicDBObject("name", john);
      // finds all people with "name" matching /joh?n/i
      DBCursor cursor = collection.find(query);

   
   4.3，日期类型 
 

java.util.Date now = new java.util.Date();
      BasicDBObject time = new BasicDBObject("ts", now);
      collection.save(time);

   
   4.4, 数组 

ArrayList x = new ArrayList();
     x.add(1);
     x.add(2);
     x.add(new BasicDBObject("foo", "bar"));
     x.add(4);
     BasicDBObject doc = new BasicDBObject("x", x);

   4.5，二进制数据 
   字节数组（byte[]）会被自动包装成二进制类型。 
   
   4.6，时间 
   Timestamp会被转换成BSONTimestamp。 
   
   4.7，源代码数据 
   源代码数据代表了JavaScript代码。CodeWScope类代表了这种数据。 
   
   
   
   5，高级操作部分 
   
   5.1，数据据安全 
   
   为了使MongoDB安全生效，必须以--auth参数启动，同时还要在db.system.users文档中增加用户信息 
   
   如果在db.system.users中无数据，即使以--auth启动，对于本地的访问也是允许的。 
   
   增加一个新的用户：db.addUser("foo", "bar"); 
   查询刚才增加的用户：db.system.users.find(); 
   删除用户：db.removeUser("foo"); 
   为了提高查询性能和安全性，也可增加只读用户：db.addUser("foo", "bar", true); 
   
   
   此时虽然用户已经有了，但是怎么去测试是否生效了呢？先进行认证测试一下，如下： 
   db.auth("foo", "bar"); 
   如果在服务端打出1则表示认证通过，客户端可以使用了，如果是0表示不通过 
   
   那么在客户端可以通过如下代码进行认证： 
   db.authenticate("foo", "bar".toCharArray()); 
   由此可知，所有的用户信息是加在数据库上面的，每个库都有自己的用户信息。 
   
   如此便可增加安全认证功能了！ 
   
   
   
   
5.2，引用vs 内嵌 

在关系型数据库中，我们可以通过外键引用来表达一对多关联，建立中间表来表达多对多关联。在MongoDB中却没有这种机制，我们可以通过对象的引用关系来实现这种关联，也可以把关联的文档内嵌到文档当中。 
对于引用这种方式，我们可以通DBRef这个类进行实现。 

那么在实际工作当中，我们应该选择哪种存储方式，有如下规则： 
1） 顶层对象应该有自己的集合 
2） 明细对象应该被嵌入父对象，例如OrderDetail与Order 
3） 拥有包含关系的对易用应该被嵌入 
4） 对于多对多关联应该使用数据库引用 
5） 对于那种稳定的比较小的集合可以在服务器端将其缓存起来从而提高性能 
6） 不能去引用一个嵌入的对象，至少目前还无法实现 
7） 我们很难去统计嵌入的对象 
8） 如果嵌入的对象太多太大会导致单个对象达到他的最大值 
9） 记住最后一条：如果遇到性能问题，那么请使用嵌入方式进行存储 

5.3，数据库优化 

1）对于排序的字段，请加入索引 
现在根据y字段倒序显示：db.user.find().sort({y: -1});，为了提高性能那么需要在字段y上加入索引 
db.user.ensureIndex({y:1});这样一来，就可以根据索引排序，而不是直接查绚集合中的所有文档。 
2）限制最大记录数：db.user.find().limit(10); 
3）只查询所需要的键，而不是所有全查出来：db.user.find({}, {y: 1}); 
4）统计记录条数利用count()方法：db.user.find().count(); 
5）强制使用指定索引：db.user.find().hint({y: 1}); 

5.4，高级查询 

1）利用索引提高查询速度 
首先我们在x字段上建立索引：db.user.ensuerIndex({x : 1}); 
然后再查询：db.user.find({x:8}, {_id: 0, x: 1}).explain(); 会有如下输出： 

{
        "cursor" : "BtreeCursor x_1",
        "nscanned" : 19,
        "nscannedObjects" : 19,
        "n" : 19,
        "millis" : 0,
        "nYields" : 0,
        "nChunkSkips" : 0,
        "isMultiKey" : false,
        "indexOnly" : true,
        ……………………….
}

其中"indexOnly" : true代表着此次查询启用了索引。 
一般的查询不会利用索引，除非满足以下条件， 
A） 必须列出要返回的字段名，这样才能决定是否需要启用索引 
B） 必须显示的指出不显示_id字段{ _id : 0} 

2）利用“.”（点号）进行对象间的导航 
> db.user.find({}, {“x.y” : 1}); 

3）查询指定范围的值：db.user.find({y: {$gt : 4, $lt : 10}}); // 4 < y < 10 


4）匹配所有$all：db.things.find( { a: { $all: [ 2, 3 ] } } ); 

5）存在性判断$exists： 
db.things.find( { a : { $exists : true } } ); // 如果存在则返回 
db.things.find( { a : { $exists : false } } ); // 如果不存在则返回 

6）求余$mod：db.things.find( "this.a % 10 == 1")，也可写成如下形式： 
db.things.find( { a : { $mod : [ 10 , 1 ] } } ) 

7）不等于$ne：db.things.find( { x : { $ne : 3 } } ); 

8）IN子句$in：db.things.find({j:{$in: [2,4,6]}}); 

9）Not In子句$nin：db.things.find({j:{$nin: [2,4,6]}}); 

10）OR条件$or：db.foo.find( { $or : [ { a : 1 } , { b : 2 } ] } ) 

11）利用正则表达式进行复杂匹配 

db.customers.find( { name : /acme.*corp/i } );
db.customers.find( { name : { $regex : 'acme.*corp', $options: 'i' } } );
db.customers.find( { name : { $regex : /acme.*corp/i, $nin : ['acmeblahcorp'] } } );

i表示大小写不敏感 

12）取反操作$not：db.customers.find( { name : { $not : /acme.*corp/i } } ); 

13）统计文档数： 
nstudents = db.students.find({'address.state' : 'CA'}).count(); 
不要这样做，这样会导致客户端排序，增加网络传输 
nstudents = db.students.find({'address.state' : 'CA'}).toArray().length; // VERY BAD 

14）分页查询：

n = db.students.find().skip(20).limit(10).count(true);

15）排序sort()：

db.myCollection.find().sort( { ts : -1 } ); // 按TS降序排列