Mongodb 基础

最新推荐文章于 2020-12-19 11:30:03 发布

weixin_33896726

最新推荐文章于 2020-12-19 11:30:03 发布

阅读量119

点赞数

文章标签：数据库 php java

原文链接：https://my.oschina.net/orange666/blog/1490443

版权

2019独角兽企业重金招聘Python工程师标准>>>

mongodb

标签（空格分隔）：数据库

基础配置

引入jar包 image_1b9lma0j5h971dd71im8v916v89.png-32.5kB

连接数据库

public class MongoDBJDBC{
   public static void main( String args[] ){
      try{   
       // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
       
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
       System.out.println("Connect to database successfully");
        
      }catch(Exception e){
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
     }
   }
}

本实例中 Mongo 数据库无需用户名密码验证。如果你的 Mongo 需要验证用户名及密码，可以使用以下代码

public class MongoDBJDBC {  
    public static void main(String[] args){  
        try {  
            //连接到MongoDB服务 如果是远程连接可以替换“localhost”为服务器所在IP地址  
            //ServerAddress()两个参数分别为 服务器地址 和 端口  
            ServerAddress serverAddress = new ServerAddress("localhost",27017);  
            List<ServerAddress> addrs = new ArrayList<ServerAddress>();  
            addrs.add(serverAddress);  
              
            //MongoCredential.createScramSha1Credential()三个参数分别为 用户名 数据库名称 密码  
            MongoCredential credential = MongoCredential.createScramSha1Credential("username", "databaseName", "password".toCharArray());  
            List<MongoCredential> credentials = new ArrayList<MongoCredential>();  
            credentials.add(credential);  
              
            //通过连接认证获取MongoDB连接  
            MongoClient mongoClient = new MongoClient(addrs,credentials);  
              
            //连接到数据库  
            MongoDatabase mongoDatabase = mongoClient.getDatabase("databaseName");  
            System.out.println("Connect to database successfully");  
        } catch (Exception e) {  
            System.err.println( e.getClass().getName() + ": " + e.getMessage() );  
        }  
    }  
}

创建集合

public class MongoDBJDBC{
   public static void main( String args[] ){
      try{   
      // 连接到 mongodb 服务
      MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
         
      // 连接到数据库
      MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
      System.out.println("Connect to database successfully");
      mongoDatabase.createCollection("test");
      System.out.println("集合创建成功");
        
      }catch(Exception e){
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
     }
   }
}

获取集合

public class MongoDBJDBC{
   public static void main( String args[] ){
      try{   
       // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
       
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
       System.out.println("Connect to database successfully");
      
       MongoCollection<Document> collection = mongoDatabase.getCollection("test");
       System.out.println("集合 test 选择成功");
      }catch(Exception e){
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
     }
   }
}

插入操作

public class MongoDBJDBC{
   public static void main( String args[] ){
      try{   
         // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
         
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
         System.out.println("Connect to database successfully");
         
         MongoCollection<Document> collection = mongoDatabase.getCollection("test");
         System.out.println("集合 test 选择成功");
         //插入文档  
         /** 
         * 1. 创建文档 org.bson.Document 参数为key-value的格式 
         * 2. 创建文档集合List<Document> 
         * 3. 将文档集合插入数据库集合中 mongoCollection.insertMany(List<Document>) 插入单个文档可以用 mongoCollection.insertOne(Document) 
         * */
         Document document = new Document("title", "MongoDB").  
         append("description", "database").  
         append("likes", 100).  
         append("by", "Fly");  
         List<Document> documents = new ArrayList<Document>();  
         documents.add(document);  
         collection.insertMany(documents);  
         System.out.println("文档插入成功");  
      }catch(Exception e){
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      }
   }
}

项目中的使用

Document doc = new Document();
// 复制题目组
Document doc1 = new Document("NodeId", targetGroupId).append("NodeType", TypeCode.COURSE_TOPIC)
                            .append("Orders", ut.getSequence());
docList.add(doc1);
// 保存课件
 Document doc1 = new Document("NodeId", courseWareId).append("NodeType", TypeCode.COURSE_WARE)
                        .append("Orders", ucw.getSequence()).append("Courseware", cw.getFileUrl())
                        .append("CoursewareTime", cw.getFileLength());
docList.add(doc1);
 // mongo增加讲次
Document doc2 = new Document();
doc2.append("SayId", targetUnitId).append("SayName", unit.getTitle())
            .append("Intro", unit.getIntroduction())
            .append("CreateUid", token).append("Status", TypeCode.MONGO_STATUS_TRUE).append("Orders", index)
            .append("Nodes", docList);
Document document = new Document("Says", doc2);
//筛选条件
Bson filter = Filters.eq("CourseId", targetCourseId);
MongoAPI.instance.operateByFilter(databaseName, tableName, filter, "$push", document);

删除操作

public class MongoDBJDBC{
   public static void main( String args[] ){
      try{   
         // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );

         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
         System.out.println("Connect to database successfully");

         MongoCollection<Document> collection = mongoDatabase.getCollection("test");
         System.out.println("集合 test 选择成功");

         //删除符合条件的第一个文档  
         collection.deleteOne(Filters.eq("likes", 200));  
         //删除所有符合条件的文档  
         collection.deleteMany (Filters.eq("likes", 200));  
         //检索查看结果  
         FindIterable<Document> findIterable = collection.find();  
         MongoCursor<Document> mongoCursor = findIterable.iterator();  
         while(mongoCursor.hasNext()){  
           System.out.println(mongoCursor.next());  
         }  
           
      }catch(Exception e){
        System.err.println( e.getClass().getName() + ": " + e.getMessage() );
     }
   }
}

项目中的应用

Document document = new Document("Says", new Document("SayId", unitId));
Bson filter = Filters.and(Filters.eq("CourseId", courseId),
                          Filters.eq("CreateUid", courseUnitListParam.getToken()));
String operate = "$pull";
MongoAPI.instance.operateByFilter(databaseName, tableName, filter, operate,document);

查询操作

public class MongoDBJDBC{
   public static void main( String args[] ){
      try{   
         // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
         
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
         System.out.println("Connect to database successfully");
         
         MongoCollection<Document> collection = mongoDatabase.getCollection("test");
         System.out.println("集合 test 选择成功");
         
         //检索所有文档  
         /** 
         * 1. 获取迭代器FindIterable<Document> 
         * 2. 获取游标MongoCursor<Document> 
         * 3. 通过游标遍历检索出的文档集合 
         * */  
         FindIterable<Document> findIterable = collection.find();  
         MongoCursor<Document> mongoCursor = findIterable.iterator();  
         while(mongoCursor.hasNext()){  
            System.out.println(mongoCursor.next());  
         }  
      
      }catch(Exception e){
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      }
   }
}

更新文档

public class MongoDBJDBC{
   public static void main( String args[] ){
      try{   
         // 连接到 mongodb 服务
         MongoClient mongoClient = new MongoClient( "localhost" , 27017 );
         
         // 连接到数据库
         MongoDatabase mongoDatabase = mongoClient.getDatabase("mycol");  
         System.out.println("Connect to database successfully");
         
         MongoCollection<Document> collection = mongoDatabase.getCollection("test");
         System.out.println("集合 test 选择成功");
         
         //更新文档   将文档中likes=100的文档修改为likes=200   
         collection.updateMany(Filters.eq("likes", 100), new Document("$set",new Document("likes",200)));  
         //检索查看结果  
         FindIterable<Document> findIterable = collection.find();  
         MongoCursor<Document> mongoCursor = findIterable.iterator();  
         while(mongoCursor.hasNext()){  
            System.out.println(mongoCursor.next());  
         }  
      
      }catch(Exception e){
         System.err.println( e.getClass().getName() + ": " + e.getMessage() );
      }
   }
}

基础CMD操作

连接

使用用户名和密码连接登陆到默认数据库：

$ ./mongo
MongoDB shell version: 3.0.6
connecting to: test

使用用户 admin 使用密码 123456 连接到本地的 MongoDB 服务上。输出结果如下所示：

> mongodb://admin:123456@localhost/
...

使用用户名和密码连接登陆到指定数据库，格式如下：

mongodb://admin:123456@localhost/test

连接 replica pair, 服务器1为example1.com服务器2为example2。

mongodb://example1.com:27017,example2.com:27017

连接 replica set 三台服务器 (端口 27017, 27018, 和27019):

mongodb://localhost,localhost:27018,localhost:27019

连接 replica set 三台服务器, 写入操作应用在主服务器并且分布查询到从服务器。

mongodb://host1,host2,host3/?slaveOk=true

直接连接第一个服务器，无论是replica set一部分或者主服务器或者从服务器。

mongodb://host1,host2,host3/?connect=direct;slaveOk=true

以安全模式连接到replica set，并且等待至少两个复制服务器成功写入，超时时间设置为2秒。

mongodb://host1,host2,host3/?safe=true;w=2;wtimeoutMS=2000

创建

1.1 show dbs 查看当前的数据库 1.2 use databaseName 选库 1.3 show tables/collections 查看当前库下的collection 1.4 db.createCollection(‘collectionName’) 创建库(该库下创建collection,即可创建库)

> use runoob
switched to db runoob
> db
runoob
>

删除

删除数据库

> use runoob
switched to db runoob
> db.dropDatabase()
{ "dropped" : "runoob", "ok" : 1 }

删除集合： 以下实例删除了 runoob 数据库中的集合 site：

> use runoob
switched to db runoob
> show tables
site
> db.site.drop()
true
> show tables
>

插入

mongodb存储的是文档,. 文档是json格式的对象. 语法: db.collectionName.insnert(document);

1: 增加单篇文档
Db.collectionName.insert({title:’nice day’});

2: 增加单个文档,并指定_id
Db.collectionName.insert({_id:8,age:78,name:’lisi’});

3.增加多个文档
db.collectionName.insert(
  [
    {time:'friday',study:'mongodb'},
    {_id:9,gender:'male',name:'QQ'}
  ]
)

# col 是我们的集合名
>db.col.insert({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
})

或者---》

> document=({title: 'MongoDB 教程', 
    description: 'MongoDB 是一个 Nosql 数据库',
    by: '菜鸟教程',
    url: 'http://www.runoob.com',
    tags: ['mongodb', 'database', 'NoSQL'],
    likes: 100
});

> db.col.insert(document)
WriteResult({ "nInserted" : 1 })
>

更新

改谁? --- 查询表达式改成什么样? -- 新值或赋值表达式操作选项 ----- 可选参数

语法:db.collection.update(查询表达式,新值,选项);

db.news.update({name:'QQ'},{name:'MSN'});  [不推荐]
是指选中news表中,name值为QQ的文档,并把其文档值改为{name:’MSN’},
#结果: 文档中的其他列也不见了,改后只有_id和name列了.
#即--新文档直接替换了旧文档,而不是修改

如果是想修改文档的某列,可以用$set关键字
db.collectionName.update(query,{$set:{name:’QQ’}})

>db.col.update({'title':'MongoDB 教程'},{$set:{'title':'MongoDB'}})
WriteResult({ "nMatched" : 1, "nUpserted" : 0, "nModified" : 1 })   # 输出信息
> db.col.find().pretty()
{
        "_id" : ObjectId("56064f89ade2f21f36b03136"),
        "title" : "MongoDB",
        "description" : "MongoDB 是一个 Nosql 数据库",
        "by" : "菜鸟教程",
        "url" : "http://www.runoob.com",
        "tags" : [
                "mongodb",
                "database",
                "NoSQL"
        ],
        "likes" : 100
}

只更新第一条记录： db.col.update( { "count" : { $gt : 1 } } , { $set : { "test2" : "OK"} } ); 全部更新： db.col.update( { "count" : { $gt : 3 } } , { $set : { "test2" : "OK"} },false,true ); 只添加第一条： db.col.update( { "count" : { $gt : 4 } } , { $set : { "test5" : "OK"} },true,false ); 全部添加加进去: db.col.update( { "count" : { $gt : 5 } } , { $set : { "test5" : "OK"} },true,true ); 全部更新： db.col.update( { "count" : { $gt : 15 } } , { $inc : { "count" : 1} },false,true ); 只更新第一条记录： db.col.update( { "count" : { $gt : 10 } } , { $inc : { "count" : 1} },false,false ); image_1bea16ubi6ur1kl914b11npft419.png-153.8kB

删除文档

语法: db.collection.remove(查询表达式, 选项); 选项是指 {justOne:true/false},是否只删一行, 默认为false

例1: db.stu.remove({sn:’001’});
删除stu表中 sn属性值为’001’的所有文档 

例2: db.stu.remove({gender:’m’,true});
删除stu表中gender属性为m的文档,只删除1行.

>db.col.remove({'title':'MongoDB 教程'})
WriteResult({ "nRemoved" : 2 })           # 删除了两条数据
>db.col.find()
……                                        # 没有数据

#如果你只想删除第一条找到的记录可以设置 justOne 为 1，如下所示：
>db.COLLECTION_NAME.remove(DELETION_CRITERIA,1)

image_1bea1dlle1v45vbd1l0gqlkuffm.png-42.9kB image_1bea1il7a8cjtbi1j718dl10lc1g.png-153.8kB

查询文档

如果你需要以易读的方式来读取数据，可以使用 pretty() 方法，语法格式如下：

>db.col.find().pretty()

image_1bc7a7ggrb1i6e01aicck1115e9.png-40.2kB

AND 条件 MongoDB 的 find() 方法可以传入多个键(key)，每个键(key)以逗号隔开，及常规 SQL 的 AND 条件。

>db.col.find({key1:value1, key2:value2}).pretty()

OR 条件 使用了关键字 $or

>db.col.find(
   {
      $or: [
	     {key1: value1}, {key2:value2}
      ]
   }
).pretty()

>db.col.find({$or:[{"by":"菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()

AND 和 OR 联合使用 以下实例演示了 AND 和 OR 联合使用，类似常规 SQL 语句为： 'where likes>50 AND (by = '菜鸟教程' OR title = 'MongoDB 教程')'

>db.col.find({"likes": {$gt:50}, $or: [{"by": "菜鸟教程"},{"title": "MongoDB 教程"}]}).pretty()

条件操作符

(>) 大于 - $gt db.col.find({"likes" : {$gt : 100}})

(<) 小于 - $lt db.col.find({likes : {$lt : 150}})

(>=) 大于等于 - $gte db.col.find({likes : {$gte : 100}})

(<= ) 小于等于 - $lte db.col.find({likes : {$lte : 150}})

$type 类型操作符

$type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。 image_1bc7as4ld96o1nbqedei3r1540m.png-38.9kB 如果想获取 "col" 集合中 title 为 String 的数据，你可以使用以下命令：

db.col.find({"title" : {$type : 2}})

{ "_id" : ObjectId("56066542ade2f21f36b0313a"), "title" : "PHP 教程", "description" : "PHP 是一种创建动态交互性站点的强有力的服务器端脚本语言。", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "php" ], "likes" : 200 }
{ "_id" : ObjectId("56066549ade2f21f36b0313b"), "title" : "Java 教程", "description" : "Java 是由Sun Microsystems公司于1995年5月推出的高级程序设计语言。", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "java" ], "likes" : 150 }
{ "_id" : ObjectId("5606654fade2f21f36b0313c"), "title" : "MongoDB 教程", "description" : "MongoDB 是一个 Nosql 数据库", "by" : "菜鸟教程", "url" : "http://www.runoob.com", "tags" : [ "mongodb" ], "likes" : 100 }

Limit与Skip方法

在MongoDB中读取指定数量的数据记录，可以使用MongoDB的Limit方法，limit()方法接受一个数字参数，该参数指定从MongoDB中读取的记录条数。

> db.col.find({},{"title":1,_id:0}).limit(2)
{ "title" : "PHP 教程" }
{ "title" : "Java 教程" }
>

我们除了可以使用limit()方法来读取指定数量的数据外，还可以使用skip()方法来跳过指定数量的数据，skip方法同样接受一个数字参数作为跳过的记录条数。

#以下实例只会显示第二条文档数据
>db.col.find({},{"title":1,_id:0}).limit(1).skip(1)
{ "title" : "Java 教程" }
>
#注:skip()方法默认参数为 0 。

排序

在MongoDB中使用使用sort()方法对数据进行排序，sort()方法可以通过参数指定排序的字段，并使用 1 和 -1 来指定排序的方式，其中 1 为升序排列，而-1是用于降序排列。

>db.col.find({},{"title":1,_id:0}).sort({"likes":-1})
{ "title" : "PHP 教程" }
{ "title" : "Java 教程" }
{ "title" : "MongoDB 教程" }
>
# 注： 如果没有指定sort()方法的排序方式，默认按照文档的升序排列。

索引

索引通常能够极大的提高查询的效率，如果没有索引，MongoDB在读取数据时必须扫描集合中的每个文件并选取那些符合查询条件的记录。这种扫描全集合的查询效率是非常低的，特别在处理大量的数据时，查询可以要花费几十秒甚至几分钟，这对网站的性能是非常致命的。索引是特殊的数据结构，索引存储在一个易于遍历读取的数据集合中，索引是对数据库表中一列或多列的值进行排序的一种结构 MongoDB使用 ensureIndex() 方法来创建索引。语法中 Key 值为你要创建的索引字段，1为指定按升序创建索引，如果你想按降序来创建索引指定为-1即可。

>db.COLLECTION_NAME.ensureIndex({KEY:1})

ensureIndex() 接收可选参数，可选参数列表如下： image_1bc7bha5sh4s1tcc1u2pv1p11fp13.png-108.2kB 通过在创建索引时加background:true 的选项，让创建工作在后台执行:

db.values.ensureIndex({open: 1, close: 1}, {background: true})

聚合

MongoDB中聚合(aggregate)主要用于处理数据(诸如统计平均值,求和等)，并返回计算后的数据结果。有点类似sql语句中的 count(*)。 aggregate() 方法

>db.COLLECTION_NAME.aggregate(AGGREGATE_OPERATION)

集合计算每个作者所写的文章数，使用aggregate()计算结果如下： select by_user, count(*) from mycol group by by_user

> db.mycol.aggregate([{$group : {_id : "$by_user", num_tutorial : {$sum : 1}}}])
{
   "result" : [
      {
         "_id" : "w3cschool.cc",
         "num_tutorial" : 2
      },
      {
         "_id" : "Neo4j",
         "num_tutorial" : 1
      }
   ],
   "ok" : 1
}
>

image_1bc7bnkc61qr914bkvnm1ou01b9j1g.png-92.1kB

MongoDB的聚合管道将MongoDB文档在一个管道处理完毕后将结果传递给下一个管道处理。管道操作是可以重复的。表达式：处理输入文档并输出。表达式是无状态的，只能用于计算当前聚合管道的文档，不能处理其它的文档。这里我们介绍一下聚合框架中常用的几个操作： $project：修改输入文档的结构。可以用来重命名、增加或删除域，也可以用于创建计算结果以及嵌套文档。 $match：用于过滤数据，只输出符合条件的文档。$match使用MongoDB的标准查询操作。 $limit：用来限制MongoDB聚合管道返回的文档数。 $skip：在聚合管道中跳过指定数量的文档，并返回余下的文档。 $unwind：将文档中的某一个数组类型字段拆分成多条，每条包含数组中的一个值。 $group：将集合中的文档分组，可用于统计结果。 $sort：将输入文档排序后输出。 $geoNear：输出接近某一地理位置的有序文档。

1、$project实例

db.article.aggregate(
    { $project : {
        title : 1 ,
        author : 1 ,
    }}
 );
# 这样的话结果中就只还有_id,tilte和author三个字段了，默认情况下_id字段是被包含的，如果要想不包含_id话可以这样:
db.article.aggregate(
    { $project : {
        _id : 0 ,
        title : 1 ,
        author : 1
    }});

2.$match实例 $match用于获取分数大于70小于或等于90记录，然后将符合条件的记录送到下一阶段$group管道操作符进行处理

>db.articles.aggregate( [
                        { $match : { score : { $gt : 70, $lte : 90 } } },
                        { $group: { _id: null, count: { $sum: 1 } } }
                       ] );

3.$skip实例经过$skip管道操作符处理后，前五个文档被"过滤"掉

db.article.aggregate(
    { $skip : 5 });

复制

MongoDB复制是将数据同步在多个服务器的过程。复制提供了数据的冗余备份，并在多个服务器上存储数据副本，提高了数据的可用性，并可以保证数据的安全性。复制还允许您从硬件故障和服务中断中恢复数据。

mongodb的复制至少需要两个节点。其中一个是主节点，负责处理客户端请求，其余的都是从节点，负责复制主节点上的数据。 mongodb各个节点常见的搭配方式为：一主一从、一主多从。主节点记录在其上的所有操作oplog，从节点定期轮询主节点获取这些操作，然后对自己的数据副本执行这些操作，从而保证从节点的数据与主节点一致。 MongoDB复制结构图如下所示 image_1bc7c3fbq15jad9q1mcd87t1gio1t.png-34.4kB

1、关闭正在运行的MongoDB服务器。现在我们通过指定 --replSet 选项来启动mongoDB。--replSet 基本语法格式如下：

mongod --port "PORT" --dbpath "YOUR_DB_DATA_PATH" --replSet "REPLICA_SET_INSTANCE_NAME"
# 实例
mongod --port 27017 --dbpath "D:\set up\mongodb\data" --replSet rs0

以上实例会启动一个名为rs0的MongoDB实例，其端口号为27017。启动后打开命令提示框并连接上mongoDB服务。在Mongo客户端使用命令rs.initiate()来启动一个新的副本集。我们可以使用rs.conf()来查看副本集的配置查看副本集状态使用 rs.status() 命令

添加副本集的成员，我们需要使用多条服务器来启动mongo服务。进入Mongo客户端，并使用rs.add()方法来添加副本集的成员

>rs.add(HOST_NAME:PORT)

假设你已经启动了一个名为mongod1.net，端口号为27017的Mongo服务。在客户端命令窗口使用rs.add() 命令将其添加到副本集中，命令如下所示：

>rs.add("mongod1.net:27017")
>

MongoDB中你只能通过主节点将Mongo服务添加到副本集中，判断当前运行的Mongo服务是否为主节点可以使用命令db.isMaster() 。 MongoDB的副本集与我们常见的主从有所不同，主从在主机宕机后所有服务将停止，而副本集在主机宕机后，副本会接管主节点成为主节点，不会出现宕机的情况。

分片

在Mongodb里面存在另一种集群，就是分片技术,可以满足MongoDB数据量大量增长的需求。当MongoDB存储海量的数据时，一台机器可能不足以存储数据，也可能不足以提供可接受的读写吞吐量。这时，我们就可以通过在多台机器上分割数据，使得数据库系统能存储和处理更多的数据。 image_1bc7ce9bm6a91kco1e9l15dk1n7v2a.png-69.2kB 上图中主要有如下所述三个主要组件： Shard: 用于存储实际的数据块，实际生产环境中一个shard server角色可由几台机器组个一个replica set承担，防止主机单点故障 Config Server: mongod实例，存储了整个 ClusterMetadata，其中包括 chunk信息。 Query Routers: 前端路由，客户端由此接入，且让整个集群看上去像单一数据库，前端应用可以透明使用。

分片结构端口分布如下： Shard Server 1：27020 Shard Server 2：27021 Shard Server 3：27022 Shard Server 4：27023 Config Server ：27100 Route Process：40000

步骤一：启动Shard Server

[root@100 /]# mkdir -p /www/mongoDB/shard/s0
[root@100 /]# mkdir -p /www/mongoDB/shard/s1
[root@100 /]# mkdir -p /www/mongoDB/shard/s2
[root@100 /]# mkdir -p /www/mongoDB/shard/s3
[root@100 /]# mkdir -p /www/mongoDB/shard/log
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27020 --dbpath=/www/mongoDB/shard/s0 --logpath=/www/mongoDB/shard/log/s0.log --logappend --fork
....
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27023 --dbpath=/www/mongoDB/shard/s3 --logpath=/www/mongoDB/shard/log/s3.log --logappend --fork

步骤二：启动Config Server

[root@100 /]# mkdir -p /www/mongoDB/shard/config
[root@100 /]# /usr/local/mongoDB/bin/mongod --port 27100 --dbpath=/www/mongoDB/shard/config --logpath=/www/mongoDB/shard/log/config.log --logappend --fork

注意：这里我们完全可以像启动普通mongodb服务一样启动，不需要添加—shardsvr和configsvr参数。因为这两个参数的作用就是改变启动端口的，所以我们自行指定了端口就可以。 步骤三：启动Route Process

/usr/local/mongoDB/bin/mongos --port 40000 --configdb localhost:27100 --fork --logpath=/www/mongoDB/shard/log/route.log --chunkSize 500

mongos启动参数中，chunkSize这一项是用来指定chunk的大小的，单位是MB，默认大小为200MB.

步骤四：配置Sharding 接下来，我们使用MongoDB Shell登录到mongos，添加Shard节点

[root@100 shard]# /usr/local/mongoDB/bin/mongo admin --port 40000
MongoDB shell version: 2.0.7
connecting to: 127.0.0.1:40000/admin
mongos> db.runCommand({ addshard:"localhost:27020" })
{ "shardAdded" : "shard0000", "ok" : 1 }
......
mongos> db.runCommand({ addshard:"localhost:27029" })
{ "shardAdded" : "shard0009", "ok" : 1 }
mongos> db.runCommand({ enablesharding:"test" }) #设置分片存储的数据库
{ "ok" : 1 }
mongos> db.runCommand({ shardcollection: "test.log", key: { id:1,time:1}})
{ "collectionsharded" : "test.log", "ok" : 1 }

步骤五：程序代码内无需太大更改，直接按照连接普通的mongo数据库那样，将数据库连接接入接口40000

查询

例1:db.stu.find() 查询所有文档所有内容

例2: db.stu.find({},{gendre:1}) 查询所有文档,的gender属性 (_id属性默认总是查出来)

例3: db.stu.find({},{gender:1, _id:0}) 查询所有文档的gender属性,且不查询_id属性

例3: db.stu.find({gender:’male’},{name:1,_id:0}); 查询所有gender属性值为male的文档中的name属性

查询表达式:

1: 最简单的查询表达式 {filed:value} ,是指查询field列的值为value的文档

2: $ne --- != 查询表达式 {field:{$nq:value}} 作用--查filed列的值不等于 value 的文档

3: $nin --> not in

4: $all 语法: {field:{$all:[v1,v2..]}} 是指取出 field列是一个数组,且至少包含 v1,v2值

5: $exists 语法: {field:{$exists:1}} 作用: 查询出含有field字段的文档

6: $nor {$nor,[条件1,条件2]} 是指所有条件都不满足的文档为真返回

7:用正则表达式查询以”诺基亚”开头的商品例:db.goods.find({goods_name:/诺基亚.*/},{goods_name:1});

8: 用$where表达式来查询例: db.goods.find({$where:'this.cat_id != 3 && this.cat_id != 11'}); 注意: 用$where查询时, mongodb是把bson结构的二进制数据转换为json结构的对象, 然后比较对象的属性是否满足表达式. 速度较慢

更新

->db.user.insert({name:'lisi',age:12,sex:'male',height:123,area:'haidian'});
->db.user.update({name:'lisi'},{$set:{area:'chaoyang'},$unset:{height:1},$inc:{age:1},$rename:{sex:'gender'}});
> db.user.find();
{ "_id" : ObjectId("51fc01c4f5de93e1f2856e33"), "age" : 13, "area" : "chaoyang", "gender" : "male", "name" : "lisi" }

$setOnInsert ->相当于mysql中的列的默认值

游标操作 cursor

游标是什么? 通俗的说,游标不是查询结果,而是查询的返回资源,或者接口. 通过这个接口,你可以逐条读取. 就像php中的fopen打开文件,得到一个资源一样, 通过资源,可以一行一行的读文件.

声明游标:

var cursor = db.collectioName.find(query,projection);
Cursor.hasNext() ,判断游标是否已经取到尽头
Cursor.Next() , 取出游标的下1个单元

用while来循环游标

> var mycursor = db.bar.find({_id:{$lte:5}})
> while(mycursor.hasNext()) {
... printjson(mycursor.next());
... }

游标在分页中的应用: 如 var mycursor = db.bar.find().skip(9995); 则是查询结果中,跳过前9995行

查询第901页,每页10条则是 var mytcursor = db.bar.find().skip(9000).limit(10);

通过cursor一次性得到所有数据, 并返回数组. 例:

> var cursor = db.goods.find();
> printjson(cursor.toArray());  //看到所有行
> printjson(cursor.toArray()[2]);  //看到第2行

注意: 不要随意使用toArray() 原因: 会把所有的行立即以对象形式组织在内存里. 可以在取出少数几行时,用此功能.

索引创建

1:索引提高查询速度,降低写入速度,权衡常用的查询字段,不必在太多列上建索引 2.在mongodb中,索引可以按字段升序/降序来创建,便于排序 3.默认是用btree来组织索引文件,2.4版本以后,也允许建立hash索引.

转载于:https://my.oschina.net/orange666/blog/1490443

weixin_33896726

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫