MongoDB

1.简介

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

MongoDB 是一个介于关系数据库和非关系数据库之间的产品，是非关系数据库当中功能最丰富，最像关系数据库的。

2.安装 MongoDB

2.1下载

去官网地址，windows 版安装包下载地址：https://www.mongodb.com/try/download 在下面可以选择安装包。下载的安装包也有两种形式，一种是一键安装的 msi 文件，还有一种是解压缩就能使用的 zip 文件，我们采用解压缩 zip 文件进行安装。

2.2解压并创建 data 文件夹

解压缩，其中 bin 目录包含了所有 mongodb 的可执行命令。注：mongodb 在运行时需要指定一个数据存储的目录，所以创建一个数据存储目录，通常放置在安装目录中，此处创建 data 的目录用来存储数据，具体如下

2.3启动 MongoDB

2.3.1启动服务端

在路径进入 cmd 输入一下命令：

mongod --dbpath=..\data\db

注：启动服务器时需要指定数据存储位置，通过参数--dbpath 进行设置，可以根据需要自行设置数据存储路径。默认服务端口 27017。

2.3.2启动客户端

进入 cmd，输入以下命令：

mongo --host=127.0.0.1 --port=27017

2.2.3连接数据库

可以使用数据库客户端，这里使用的是 Navicat，左下角测试，连接成功。

3.Spring boot集成mongodb方式

spring-data-mongodb提供了MongoTemplate与MongoRepository两种方式访问mongodb。

还可以使用Mongo官方依赖访问mongodb。

• MongoRepository操作简单
• MongoTemplate操作灵活
• Mongo官方依赖

4.搭建项目环境

4.1创建springboot工程

4.2引入依赖

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-mongodb</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
    </dependency>
    <dependency>
        <groupId>org.projectlombok</groupId>
        <artifactId>lombok</artifactId>
    </dependency>
    <dependency>
        <groupId>joda-time</groupId>
        <artifactId>joda-time</artifactId>
        <version>2.10.1</version>
    </dependency>

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-test</artifactId>
        <scope>test</scope>
        <exclusions>
            <exclusion>
                <groupId>org.junit.vintage</groupId>
                <artifactId>junit-vintage-engine</artifactId>
            </exclusion>
        </exclusions>
    </dependency>
</dependencies>

4.3添加配置

在application.properties文件添加MongoDB配置

spring.data.mongodb.uri=mongodb://127.0.0.1:27017/test

5.基于MongoTemplate 开发CRUD

5.1MongoTemplate常用方法

mongoTemplate.findAll(User.class): 查询User文档的全部数据
mongoTemplate.findById(, User.class): 查询User文档id为id的数据
mongoTemplate.find(query, User.class): 根据query内的查询条件查询
mongoTemplate.upsert(query, update, User.class): 修改
mongoTemplate.remove(query, User.class): 删除
mongoTemplate.insert(User): 新增
Query对象

• 创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）
• 精准条件：criteria.and(“key”).is(“条件”)

模糊条件：criteria.and(“key”).regex(“条件”)

• 封装条件：query.addCriteria(criteria)
• 大于（创建新的criteria）：Criteria gt = Criteria.where(“key”).gt（“条件”）
• 小于（创建新的criteria）：Criteria lt = Criteria.where(“key”).lt（“条件”）
• Query.addCriteria(new Criteria().andOperator(gt,lt));
• 一个query中只能有一个andOperator()。其参数也可以是Criteria数组。
• 排序 ：query.with（new Sort(Sort.Direction.ASC, “age”). and(new Sort(Sort.Direction.DESC, “date”)))

5.2创建实体类

@Data
@Document("User")
public class User {

    @Id
    private String id;
    private String name;
    private Integer age;
    private String email;
    private String createDate;
}

5.3编写测试类，测试基于MongoTemplate 开发的增删改查

5.5.1新增数据

@Autowired
    private MongoTemplate mongoTemplate;

    //添加操作
    @Test
    void contextLoads() {
        User user = new User();
        user.setAge(20);
        user.setName("test");
        user.setEmail("123@qq.com");
        User user1 = mongoTemplate.insert(user);
        System.out.println(user1);
    }

控制台输出

5.5.2查询集合（表）全部 

//查询所有记录
@Test
 public void findAll(){
     List<User> all = mongoTemplate.findAll(User.class);
     System.out.println(all);
 }

5.5.3根据id查询

 //根据id查询
 @Test
 public void findId(){
     User user = mongoTemplate.findById("60b4b3ca861699233d33f3e2", User.class);
     System.out.println(user);
 }

5.5.4条件查询 

//条件查询
@Test
 public void findUserList(){
     Query query = new Query(Criteria.where("name").is("test").and("age").is(20));
     List<User> users = mongoTemplate.find(query, User.class);
     System.out.println(users);
 }

5.5.5模糊查询 

Pattern.compile函数用法

 //模糊条件查询
    @Test
    public void findLikeUserList(){
//        name like test
        String name = "est";
        String regex = String.format("%s%s%s", "^.*", name, ".*$");
        /*1、在使用Pattern.compile函数时，可以加入控制正则表达式的匹配行为的参数：
        Pattern Pattern.compile(String regex, int flag)
        2、regex设置匹配规则
        3、Pattern.CASE_INSENSITIVE,这个标志能让表达式忽略大小写进行匹配。*/
        Pattern pattern = Pattern.compile(regex,Pattern.CASE_INSENSITIVE);
        //创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）
        Query query = new Query(//构建查询条件
                Criteria.where("name").regex(pattern));
        List<User> users = mongoTemplate.find(query, User.class);
        System.out.println(users);
    }

查询结果：查询出来了名字里包好est的用户

5.5.6分页查询带条件 

//分页查询（带条件）
@Test
 public void pageLikeUserList(){
     int pageNo = 1;//设置当前页
     int pageSize = 3;//设置每页显示的记录数

     //条件构建
     String name = "est";
     String regex = String.format("%s%s%s", "^.*", name, ".*$");
     /*1、在使用Pattern.compile函数时，可以加入控制正则表达式的匹配行为的参数：
     Pattern Pattern.compile(String regex, int flag)
     2、regex设置匹配规则
     3、Pattern.CASE_INSENSITIVE,这个标志能让表达式忽略大小写进行匹配。*/
     Pattern pattern = Pattern.compile(regex,Pattern.CASE_INSENSITIVE);
     //创建一个query对象（用来封装所有条件对象)，再创建一个criteria对象（用来构建条件）
     Query query = new Query(//构建查询条件
             Criteria.where("name").regex(pattern));

     //分页构建
     //查询数来集合（表）中的总记录数
     long count = mongoTemplate.count(query, User.class);
     List<User> users = mongoTemplate.find(
             query.skip((pageNo - 1) * pageSize).limit(pageSize), User.class);
     System.out.println(count);
     System.out.println(users);
 }

5.5.7修改操作

 //修改操作
@Test
public void  updateUser(){
    //根据id查询
    User user = mongoTemplate.findById("60b4f89db925b61fbf529591", User.class);
    //修改值
    user.setName("test_02");
    user.setAge(2);
    user.setEmail("test_02@qq.com");

    //调用方法实现修改
    Query query = new Query(Criteria.where("_id").is(user.getId()));
    Update update = new Update();
    update.set("name",user.getName());
    update.set("age",user.getAge());
    update.set("email",user.getEmail());
    //调用mongoTemplate的修改方法实现修改
    UpdateResult upsert = mongoTemplate.upsert(query, update, User.class);
    long modifiedCount = upsert.getModifiedCount();//获取到修改受影响的行数
    System.out.println("受影响的条数："+modifiedCount);
}

 

5.5.8删除操作 

//删除条件
@Test
 public void deleteUser(){
     Query query = new Query(Criteria.where("_id").is("60b4b3ca861699233d33f3e2"));
     DeleteResult remove = mongoTemplate.remove(query, User.class);
     long deletedCount = remove.getDeletedCount();
     System.out.println("删除的条数："+deletedCount);
 }//删除条件
 @Test
 public void deleteUser(){
     Query query = new Query(Criteria.where("_id").is("60b4b3ca861699233d33f3e2"));
     DeleteResult remove = mongoTemplate.remove(query, User.class);
     long deletedCount = remove.getDeletedCount();
     System.out.println("删除的条数："+deletedCount);
 }

 控制台输出：

查看mongoDB,已经删除了该条数据 

6.基于MongoRepository开发CRUD 

Spring Data提供了对mongodb数据访问的支持，我们只需要继承MongoRepository类，按照Spring Data规范就可以了。

6.1SpringData 方法定义规范

 

1、不是随便声明的，而需要符合一定的规范
2、 查询方法以find | read | get开头
3、 涉及条件查询时，条件的属性用条件关键字连接
4、 要注意的是：条件属性首字母需要大写
5、 支持属性的级联查询，但若当前类有符合条件的属性则优先使用，而不使用级联属性,若需要使用级联属性，则属性之间使用_强制进行连接

6.2添加Repository接口

import com.demomongodb.entity.User;
import org.springframework.data.mongodb.repository.MongoRepository;
import org.springframework.stereotype.Repository;
/**
 * @Description :
 * @Author :lenovo
 * @Date :2021/6/1 10:54
 */
@Repository
public interface UserRepository extends MongoRepository<User,String> {
}

6.3添加测试类，测试CRUD 

6.3.1添加操作

@Autowired
private UserRepository userRepository;

 //添加操作
 @Test
 public void save(){
     User user = new User();
     user.setName("ertong");
     user.setAge(20);
     user.setEmail("ertong@qq.com");
     User user1 = userRepository.save(user);
     System.out.println(user1);
 }

6.3.2查询所有

//查询所有
@Test
public void findAll(){
    List<User> lists = userRepository.findAll();
    for(User user:lists){
        System.out.println(user);
    }
}

6.3.3根据id查询 

//根据id查询
@Test
public void findById(){
    User user = userRepository.findById("60b4b491861699233d33f3e3").get();
    System.out.println(user);
}

6.3.4条件查询

使用 Example example = Example.of(user);封装查询条件

//条件查询
 @Test
 public void findUserList(){
     User user = new User();
     user.setName("ertong");
     user.setAge(20);
     Example<User> example = Example.of(user);
     List<User> all = userRepository.findAll(example);
     System.out.println(all);
 }

6.3.5模糊条件查询

//模糊条件查询
@Test
public void findLikeUserList(){
    ///创建匹配器，即如何使用查询条件
    ExampleMatcher matcher = ExampleMatcher.matching()//构建对象
            .withStringMatcher(ExampleMatcher.StringMatcher.CONTAINING)//改变默认字符串匹配方式：模糊查询
            .withIgnoreCase(true);//改变默认大小写忽略方式：忽略大小写

    User user = new User();
    user.setName("e");
    user.setAge(20);
    Example<User> example = Example.of(user,matcher);
    List<User> all = userRepository.findAll(example);
    System.out.println(all);
}

6.3.6分页查询 

//分页查询
@Test
public void findPageUserAll(){
    //设置分页参数
    //0代表第一页
    Pageable pageable = PageRequest.of(0, 3);
    //查询条件
    User user = new User();
    user.setName("test");
    Example<User> userExample = Example.of(user);//查询条件
    Page<User> page = userRepository.findAll(userExample, pageable);
    System.out.println(page.getContent());
}

6.3.7修改 

//修改操作
@Test
public void updateUser(){
    //先根据id出要修改的用户
    User user = userRepository.findById("60b5a37209aa4d6face6bacd").get();
    //设置修改的值
    user.setName("haha");
    user.setAge(23);
    user.setEmail("hah@qq.com");
    User user1 = userRepository.save(user);
    System.out.println(user1);
}

 6.3.8删除

执行删除前，首先查询一些=下数据库user表中的数据

执行删除操作 

//删除
@Test
public void delete(){
   userRepository.deleteById("60b5a37209aa4d6face6bacd");
}

再次查询test数据库的user表，数据已删除

7.基于Mongo官方依赖 开发CRUD 

在 Java 程序中如果要使用 MongoDB，你需要确保已经安装了 Java 环境及 MongoDB JDBC 驱动。本章节实例适合 Mongo 3.x 以上版本。

7.1准备依赖

国内 mongodb-driver jar 下载地址：http://central.maven.org/maven2/org/mongodb/mongo-java-driver/

7.2连接数据库 

连接数据库，你需要指定数据库名称，如果指定的数据库不存在，mongo会自动创建数据库。

连接数据库的Java代码如下：

import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;

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

现在，让我们来编译运行程序并连接到数据库 mycol。

你可以根据你的实际环境改变 MongoDB JDBC 驱动的路径。

本实例将 MongoDB JDBC 启动包 mongo-java-driver-3.2.2.jar 放在本地目录下:

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

import java.util.ArrayList;  
import java.util.List;  
import com.mongodb.MongoClient;  
import com.mongodb.MongoCredential;  
import com.mongodb.ServerAddress;  
import com.mongodb.client.MongoDatabase;  
  
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() );  
        }  
    }  
} 

7.3创建集合

我们可以使用 com.mongodb.client.MongoDatabase 类中的createCollection()来创建集合

代码片段如下：

import com.mongodb.MongoClient;
import com.mongodb.client.MongoDatabase;

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

编译运行以上程序，输出结果如下:

7.4获取集合

我们可以使用com.mongodb.client.MongoDatabase类的 getCollection() 方法来获取一个集合

代码片段如下：

import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

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

编译运行以上程序，输出结果如下:

7.5插入文档

我们可以使用com.mongodb.client.MongoCollection类的 insertMany() 方法来插入一个文档

代码片段如下：

import java.util.ArrayList;
import java.util.List;
import org.bson.Document;

import com.mongodb.MongoClient;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoDatabase;

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

编译运行以上程序，输出结果如下:

7.6检索所有文档

我们可以使用 com.mongodb.client.MongoCollection 类中的 find() 方法来获取集合中的所有文档。

此方法返回一个游标，所以你需要遍历这个游标。

代码片段如下：

import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;

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

 编译运行以上程序，输出结果如下:

7.7更新文档

你可以使用 com.mongodb.client.MongoCollection 类中的 updateMany() 方法来更新集合中的文档。

代码片段如下：

import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;

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

 编译运行以上程序，输出结果如下:

7.8删除第一个文档

要删除集合中的第一个文档，首先你需要使用com.mongodb.DBCollection类中的 findOne()方法来获取第一个文档，然后使用remove 方法删除。

代码片段如下：

import org.bson.Document;
import com.mongodb.MongoClient;
import com.mongodb.client.FindIterable;
import com.mongodb.client.MongoCollection;
import com.mongodb.client.MongoCursor;
import com.mongodb.client.MongoDatabase;
import com.mongodb.client.model.Filters;

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

编译运行以上程序，输出结果如下:

更多操作可以参考：Quick Tour

参考文档：http://blog.csdn.net/ererfei/article/details/50857103

8.MongoDB DML语法

MongoDB6 中文官网

8.1MongoDB 创建数据库

8.2MongoDB 删除数据库 

8.3MongoDB 创建集合 

8.4MongoDB 数据库与集合的区别

在 MongoDB 中，一个数据库包含多个集合，类似于 MySQL 中一个数据库包含多个表；一个集合包含多个文档，类似于 MySQL 中一个表包含多条数据。

8.5MongoDB 删除集合

8.6MongoDB 插入文档

文档的数据结构和 JSON 基本一样。

所有存储在集合中的数据都是 BSON 格式。

BSON 是一种类似 JSON 的二进制形式的存储格式，是 Binary JSON 的简称。

8.7MongoDB 更新文档 

8.8MongoDB 删除文档

8.9MongoDB 查询文档 

8.10MongoDB 条件操作符

8.11MongoDB $type 操作符 

$type操作符是基于BSON类型来检索集合中匹配的数据类型，并返回结果。

MongoDB 中可以使用的类型如下表所示：

类型	数字	备注
Double	1
String	2
Object	3
Array	4
Binary data	5
Undefined	6	已废弃。
Object id	7
Boolean	8
Date	9
Null	10
Regular Expression	11
JavaScript	13
Symbol	14
JavaScript (with scope)	15
32-bit integer	16
Timestamp	17
64-bit integer	18
Min key	255	Query with -1.
Max key	127

我们使用的数据库名称为"runoob" 我们的集合名称为"col"，以下为我们插入的数据。

简单的集合"col"：

 8.12MongoDB Limit与Skip方法

8.13MongoDB 排序 

8.14MongoDB 索引 

8.15MongoDB 聚合函数 

8.16MongoDB 复制（副本集） 

以上结构图中，客户端从主节点读取数据，在客户端写入数据到主节点时， 主节点与从节点进行数据交互保障数据的一致性。 

8.17MongoDB 分片 

[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

 8.18高级部分详见

MongoDB 备份(mongodump)与恢复(mongorestore) | 菜鸟教程 (runoob.com)