一、 什么是MongoDB

MongoDB基于分布式文件存储的数据库。由C++语言编写。MongoDB是一个高性能，开源，无模式的文档型数据库，是当前NoSql数据库中比较热门的一种。

他支持的数据结构非常松散，是类似json的bjson格式，因此可以存储比较复杂的数据类型。Mongo最大的特点是他支持的查询语言非常强大，其语法有点类似于面向对象的查询语言，几乎可以实现类似关系数据库单表查询的绝大部分功能，而且还支持对数据建立索引。

传统的关系数据库一般由数据库（database）、表（table）、记录（record）三个层次概念组成，MongoDB是由数据库（database）、集合（collection）、文档对象（document）三个层次组成。MongoDB对于关系型数据库里的表，但是集合中没有列、行和关系概念，这体现了模式自由的特点。

MongoDB中的一条记录就是一个文档，是一个数据结构，由字段和值对组成。MongoDB文档与JSON对象类似。字段的值有可能包括其它文档、数组以及文档数组。

适用场景，我们可以直接用MongoDB来存储键值对类型的数据，如：验证码、Session等；由于MongoDB的横向扩展能力，也可以用来存储数据规模会在未来变的非常巨大的数据，如：日志、评论等；由于MongoDB存储数据的弱类型，也可以用来存储一些多变json数据，如：与外系统交互时经常变化的JSON报文。而对于一些对数据有复杂的高事务性要求的操作，如：账户交易等就不适合使用MongoDB来存储。

二、MongoDB优点

1.性能

在大数据时代中，大数据量的处理已经成了考量一个数据库最重要的原因之一。而MongoDB的一个主要目标就是尽可能的让数据库保持卓越的性能，这很大程度地决定了MongoDB的设计。在一个以传统机械硬盘为主导的年代，硬盘很可能会成为性能的短板，而MongoDB选择了最大程度而利用内存资源用作缓存来换取卓越的性能，并且会自动选择速度最快的索引来进行查询。MongoDB尽可能精简数据库，将尽可能多的操作交给客户端，这种方式也是MongoDB能够保持卓越性能的原因之一。

2.扩展

现在互联网的数据量已经从过去的MB、GB变为了现在的TB级别，单一的数据库显然已经无法承受，扩展性成为重要的话题，然而现在的开发人员常常在选择扩展方式的时候犯了难，到底是选择横向扩展还是纵向扩展呢？

横向扩展（scale out）是以增加分区的方式将数据库拆分成不同的区块来分布到不同的机器中来，这样的优势是扩展成本低但管理困难。

纵向扩展（scale up） 纵向扩展与横向扩展不同的是他会将原本的服务器进行升级，让其拥有更强大的计算能力。这样的优势是易于管理无需考虑扩展带来的众多问题，但缺点也显而易见，那就是成本高。一台大型机的价格往往非常昂贵，并且这样的升级在数据达到极限时，可能就找不到计算能力更为强大的机器了。

而MongoDB选择的是更为经济的横向扩展，他可以很容易的将数据拆分至不同的服务器中。而且在获取数据时开发者也无需考虑多服务器带来的问题，MongoDB可以将开发者的请求自动路由到正确的服务器中，让开发者脱离横向扩展带来的弊病，更专注于程序的开发上。

3.使用

MongoDB采用的是NoSQL的设计方式，可以更加灵活的操作数据。在进行传统的RDBMS中你一定遇到过几十行甚至上百行的复杂SQL语句，传统的RDBMS的SQL语句中包含着大量关联，子查询等语句，在增加复杂性的同时还让性能调优变得更加困难。MongoDB的面向文档（document-oriented）设计中采用更为灵活的文档来作为数据模型用来取代RDBMS中的行，面向文档的设计让开发人员获取数据的方式更加灵活，甚至于开发人员仅用一条语句即可查询复杂的嵌套关系，让开发人员不必为了获取数据而绞尽脑汁。

3. Spring Boot中MongoDB集成方式

1> 常规集成
1、pom包配置
pom包里面添加spring-boot-starter-data-mongodb包引用

<dependencies><dependency> <groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-mongodb</artifactId></dependency> 
</dependencies>

2、在application.properties中添加配置

spring.data.mongodb.uri=mongodb://name:pass@localhost:27017/test

多个IP集群可以采用以下配置：

spring.data.mongodb.uri=mongodb://user:pwd@ip1:port1,ip2:port2/database

3、创建数据实体

public class UserEntity implements Serializable {private static final long serialVersionUID = -3258839839160856613L;private Long id;private String userName;private String passWord;//getter、setter省略
}

4、创建实体dao的增删改查操作
dao层实现了UserEntity对象的增删改查

@Component
public class UserDaoImpl implements UserDao {@Autowiredprivate MongoTemplate mongoTemplate;/*** 创建对象* @param user*/@Overridepublic void saveUser(UserEntity user) {mongoTemplate.save(user);}/*** 根据用户名查询对象* @param userName* @return*/@Overridepublic UserEntity findUserByUserName(String userName) {Query query=new Query(Criteria.where("userName").is(userName));UserEntity user =  mongoTemplate.findOne(query , UserEntity.class);return user;}/*** 更新对象* @param user*/@Overridepublic void updateUser(UserEntity user) {Query query=new Query(Criteria.where("id").is(user.getId()));Update update= new Update().set("userName", user.getUserName()).set("passWord", user.getPassWord());//更新查询返回结果集的第一条mongoTemplate.updateFirst(query,update,UserEntity.class);//更新查询返回结果集的所有// mongoTemplate.updateMulti(query,update,UserEntity.class);}/*** 删除对象* @param id*/@Overridepublic void deleteUserById(Long id) {Query query=new Query(Criteria.where("id").is(id));mongoTemplate.remove(query,UserEntity.class);}
}

5、开发对应的测试方法

@RunWith(SpringRunner.class)
@SpringBootTest
public class UserDaoTest {@Autowiredprivate UserDao userDao;@Testpublic void testSaveUser() throws Exception {UserEntity user=new UserEntity();user.setId(2l);user.setUserName("小明");user.setPassWord("fffooo123");userDao.saveUser(user);}@Testpublic void findUserByUserName(){UserEntity user= userDao.findUserByUserName("小明");System.out.println("user is "+user);}@Testpublic void updateUser(){UserEntity user=new UserEntity();user.setId(2l);user.setUserName("天空");user.setPassWord("fffxxxx");userDao.updateUser(user);}@Testpublic void deleteUserById(){userDao.deleteUserById(1l);}}

6、查看验证结果
可以使用工具mongoVUE工具来连接后直接图形化展示查看，也可以登录服务器用命令来查看

1.登录mongos

bin/mongo -host localhost -port 20000

2、切换到test库

use test

3、查询userEntity集合数据

db.userEntity.find()

根据3查询的结果来观察测试用例的执行是否正确。到此springboot对应mongodb的增删改查功能已经全部实现。

2> 多数据源集成
1、pom包配置
添加lombok和spring-boot-autoconfigure包引用

<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-mongodb</artifactId>
</dependency>
<dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId>
</dependency>
<dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-autoconfigure</artifactId><version>RELEASE</version>
</dependency>

Lombok - 是一个可以通过简单的注解形式来帮助我们简化消除一些必须有但显得很臃肿的Java代码的工具，通过使用对应的注解，可以在编译源码的时候生成对应的方法。简单试了以下这个工具还挺好玩的，加上注解我们就不用手动写 getter\setter、构建方式类似的代码了。
spring-boot-autoconfigure - 就是spring boot的自动化配置

2、配置文件使用YAML的形式添加两条数据源，如下：

mongodb:primary:host: 192.168.9.60port: 20000database: testsecondary:host: 192.168.9.60port: 20000database: test1

3、配置两个库的数据源
封装读取以mongodb开头的两个配置文件

@Data
@ConfigurationProperties(prefix = "mongodb")
public class MultipleMongoProperties {private MongoProperties primary = new MongoProperties();private MongoProperties secondary = new MongoProperties();
}

配置不同包路径下使用不同的数据源

第一个库的封装

@Configuration
@EnableMongoRepositories(basePackages = "com.neo.model.repository.primary",mongoTemplateRef = PrimaryMongoConfig.MONGO_TEMPLATE)
public class PrimaryMongoConfig {protected static final String MONGO_TEMPLATE = "primaryMongoTemplate";
}

第二个库的封装

@Configuration
@EnableMongoRepositories(basePackages = "com.neo.model.repository.secondary",mongoTemplateRef = SecondaryMongoConfig.MONGO_TEMPLATE)
public class SecondaryMongoConfig {protected static final String MONGO_TEMPLATE = "secondaryMongoTemplate";
}

读取对应的配置信息并且构造对应的MongoTemplate

@Configuration
public class MultipleMongoConfig {@Autowiredprivate MultipleMongoProperties mongoProperties;@Primary@Bean(name = PrimaryMongoConfig.MONGO_TEMPLATE)public MongoTemplate primaryMongoTemplate() throws Exception {return new MongoTemplate(primaryFactory(this.mongoProperties.getPrimary()));}@Bean@Qualifier(SecondaryMongoConfig.MONGO_TEMPLATE)public MongoTemplate secondaryMongoTemplate() throws Exception {return new MongoTemplate(secondaryFactory(this.mongoProperties.getSecondary()));}@Bean@Primarypublic MongoDbFactory primaryFactory(MongoProperties mongo) throws Exception {return new SimpleMongoDbFactory(new MongoClient(mongo.getHost(), mongo.getPort()),mongo.getDatabase());}@Beanpublic MongoDbFactory secondaryFactory(MongoProperties mongo) throws Exception {return new SimpleMongoDbFactory(new MongoClient(mongo.getHost(), mongo.getPort()),mongo.getDatabase());}
}

两个库的配置信息已经完成。

4、创建两个库分别对应的对象和Repository
借助lombok来构建对象

@Data
@AllArgsConstructor
@NoArgsConstructor
@Document(collection = "first_mongo")
public class PrimaryMongoObject {@Idprivate String id;private String value;@Overridepublic String toString() {return "PrimaryMongoObject{" + "id='" + id + '\'' + ", value='" + value + '\''+ '}';}
}

对应的Repository

public interface PrimaryRepository extends MongoRepository<PrimaryMongoObject, String> {
}

继承了 MongoRepository 会默认实现很多基本的增删改查，省了很多自己写dao层的代码

Secondary和上面的代码类似就不贴出来了

5、最后测试

@RunWith(SpringRunner.class)
@SpringBootTest
public class MuliDatabaseTest {@Autowiredprivate PrimaryRepository primaryRepository;@Autowiredprivate SecondaryRepository secondaryRepository;@Testpublic void TestSave() {System.out.println("************************************************************");System.out.println("测试开始");System.out.println("************************************************************");this.primaryRepository.save(new PrimaryMongoObject(null, "第一个库的对象"));this.secondaryRepository.save(new SecondaryMongoObject(null, "第二个库的对象"));List<PrimaryMongoObject> primaries = this.primaryRepository.findAll();for (PrimaryMongoObject primary : primaries) {System.out.println(primary.toString());}List<SecondaryMongoObject> secondaries = this.secondaryRepository.findAll();for (SecondaryMongoObject secondary : secondaries) {System.out.println(secondary.toString());}System.out.println("************************************************************");System.out.println("测试完成");System.out.println("************************************************************");}
}

到此，mongodb多数据源的使用已经完成。

3> Spring Boot中使用MongoDB的连接池配置

Spring Boot中通过依赖spring-boot-starter-data-mongodb，来实现spring-data-mongodb的自动配置。但是默认情况下，Spring Boot 中，并没有像使用MySQL或者Redis一样，提供了连接池配置的功能。因此，我们需要自行重写 MongoDbFactory，实现MongoDB客户端连接的参数配置扩展。

需要说明的是，MongoDB的客户端本身就是一个连接池，因此，我们只需要配置客户端即可。

1、 配置文件
为了统一Spring Boot的配置，我们要将重写的配置也配置到 application.yml中，前缀为spring.data.mongodb.custom下（前缀可自己随意配置）：

spring:data:mongodb:custom:hosts:- 10.0.5.1- 10.0.5.1ports:- 27017- 27018replica-set: mgset-3590061username: janceepassword: abc123database: janceeauthentication-database: adminconnections-per-host: 20min-connections-per-host: 20

该配置例子中，配置了副本集，其中包含了主机10.0.5.1:27017和10.0.5.1:27018，其它配置与Spring Boot的标准配置类似，另外，connections-per-host为客户端的连接数，in-connections-per-host为客户端最小连接数。

这里做个拓展，配置中的replica-set: mgset-3590061是Mongo三种集群方式中的一种。下面的集群搭建中会详细说明。

2、 将配置包装成类
为方便调用和可读性，将上述配置包装成一个配置实体类，MongoConfig.java代码如下:

package com.feidiao.jancee.fdiot.api.config.mongo;import org.hibernate.validator.constraints.NotBlank;
import org.hibernate.validator.constraints.NotEmpty;
import org.springframework.stereotype.Component;
import org.springframework.validation.annotation.Validated;import java.util.List;@Component
@Validated
public class MongoSettingsProperties {@NotBlankprivate String database;@NotEmptyprivate List<String> hosts;@NotEmptyprivate List<Integer> ports;private String replicaSet;private String username;private String password;private String authenticationDatabase;private Integer minConnectionsPerHost = 10;private Integer connectionsPerHost = 2;public MongoSettingsProperties() {}// get、set方法...
}

3、 覆盖MongoDbFactory
接下来，就是覆盖Spring Boot原有的MongoDbFactory Bean，新建文件MongoConfig.java，代码如下：

import com.mongodb.MongoClient;
import com.mongodb.MongoClientOptions;
import com.mongodb.MongoCredential;
import com.mongodb.ServerAddress;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.mongodb.MongoDbFactory;
import org.springframework.data.mongodb.core.SimpleMongoDbFactory;import java.util.ArrayList;
import java.util.List;@Configuration
public class MongoConfig {// 注入配置实体@Autowiredprivate MongoSettingsProperties mongoSettingsProperties;@Bean@ConfigurationProperties(prefix = "spring.data.mongodb.custom")MongoSettingsProperties mongoSettingsProperties() {return new MongoSettingsProperties();}// 覆盖默认的MongoDbFactory@BeanMongoDbFactory mongoDbFactory() {//客户端配置（连接数、副本集群验证）MongoClientOptions.Builder builder = new MongoClientOptions.Builder();builder.connectionsPerHost(mongoSettingsProperties.getConnectionsPerHost());builder.minConnectionsPerHost(mongoSettingsProperties.getMinConnectionsPerHost());if (mongoSettingsProperties.getReplicaSet() != null) {builder.requiredReplicaSetName(mongoSettingsProperties.getReplicaSet());}MongoClientOptions mongoClientOptions = builder.build();// MongoDB地址列表List<ServerAddress> serverAddresses = new ArrayList<>();for (String host : mongoSettingsProperties.getHosts()) {Integer index = mongoSettingsProperties.getHosts().indexOf(host);Integer port = mongoSettingsProperties.getPorts().get(index);ServerAddress serverAddress = new ServerAddress(host, port);serverAddresses.add(serverAddress);}System.out.println("serverAddresses:" + serverAddresses.toString());// 连接认证List<MongoCredential> mongoCredentialList = new ArrayList<>();if (mongoSettingsProperties.getUsername() != null) {mongoCredentialList.add(MongoCredential.createScramSha1Credential(mongoSettingsProperties.getUsername(),mongoSettingsProperties.getAuthenticationDatabase() != null ? mongoSettingsProperties.getAuthenticationDatabase() : mongoSettingsProperties.getDatabase(),mongoSettingsProperties.getPassword().toCharArray()));}System.out.println("mongoCredentialList:" + mongoCredentialList.toString());//创建客户端和FactoryMongoClient mongoClient = new MongoClient(serverAddresses, mongoCredentialList, mongoClientOptions);MongoDbFactory mongoDbFactory = new SimpleMongoDbFactory(mongoClient, mongoSettingsProperties.getDatabase());return mongoDbFactory;}
}

在这里，实现了MongoDB连接时，前面配置的参数的设置，按照自己的实际情况，可以在new SimpleMongoDbFactory时，增加修改自己需要的配置参数。

至此，就完成了全部配置，运行测试即可。

4. MongoDB中的基础概念：Databases、Collections、Documents(这一节比较基础，比较基础，知道就好)

1> 基础概念
MongoDB以BSON格式的文档（Documents）形式存储。Databases中包含集合（Collections），集合（Collections）中存储文档（Documents）。

BSON是一个二进制形式的JSON文档，它比JSON包含更多的数据类型。

Databases在MongoDB中，databases保存文档（Documents）的集合（Collections）。

2> 基本操作命令
在Mongo Shell中，通过使用use 命令来选中database，就像下面的例子：

use myDB

- 创建Database
如果database不存在，MongoDB会在第一次为database存储数据的时候创建。因此，你可以直接切换到一个不存在的数据库，然后执行下面的语句：

use myNewDBdb.myNewCollection1.insert( { x: 1 } )

insert()操作会创建名为myNewDB的database和名为myNewCollection1的collection（如果他们不存在的话）。

Collections是MongoDB在collections中存储文档（documents）。Collections类似于关系型数据库中的表（tables）。

- 创建Collection
如果collection不存在，MongoDB会在第一次为collection存储数据的时候创建。

db.myNewCollection2.insert( { x: 1 } )
db.myNewCollection3.createIndex( { y: 1 } )

无论是insert()还是createIndex()操作，都会创建它们各自指定的收集，如果他们不存在的话。

- 显式创建
MongoDB提供db.createCollection()方法来显式创建一个collection，同时还能设置各种选项，例如：设置最大尺寸和文档校验规则。如果你没有指定这些选项，那么你就不需要显式创建collection，因为MongoDB会在你创建第一个数据的时候自动创建collection。

若要修改这些collection选择，可查看collMod。

- Documents校验
3.2.x版本新增内容。
默认情况下，collection不要求文档有相同的结构；例如，在一个collection的文档不必具有相同的fields，对于单个field在一个collection中的不同文档中可以是不同的数据类型。

从MongoDB 3.2开始，你可以在对collection进行update和insert操作的时候执行文档（documents）校验规则。具体可参见文档验证的详细信息。

3> Document结构
MongoDB的文件是由field和value对的结构组成，例如下面这样的结构：

{field1: value1,field2: value2,field3: value3,...fieldN: valueN
}

value值可以是任何BSON数据类型，包括：其他document，数字，和document数组。

例如下面的document，包含各种不同类型的值：

var mydoc = {_id: ObjectId("5099803df3f4948bd2f98391"),name: { first: "Alan", last: "Turing" },birth: new Date('Jun 23, 1912'),death: new Date('Jun 07, 1954'),contribs: [ "Turing machine", "Turing test", "Turingery" ],views : NumberLong(1250000)
}

上面例子中的各fields有下列数据类型：

_id：ObjectId类型
name：一个嵌入的document，包含first和last字段
birth和death：Date类型
contribs：字符串数组
views：NumberLong类型
Field名
Field名是一个字符串。

5> Documents中的filed名有下列限制：

_id被保留用于主键；其值必须是集合中唯一的、不可变的、并且可以是数组以外的任何数据类型
不能以美元符号$开头
不能包含点字符.
不能包含空字符
Field Value限制
对于索引的collections，索引字段中的值有最大长度限制。详情请参见Maximum Index Key Length。

圆点符号
MongoDB中使用圆点符号.访问数组中的元素，也可以访问嵌入式Documents的fields。

Arrays数组
通过圆点符号.来链接Arrays数组名字和从0开始的数字位置，来定位和访问一个元素数组：

“.”
举例：对于下面的document：

{...contribs: [ "Turing machine", "Turing test", "Turingery" ],...
}

要访问contribs数组中的第三个元素，可以这样访问：

“contribs.2”
嵌入式Documents
通过圆点符号.来链接嵌入式document的名字和field名，来定位和访问嵌入式document：

“.”
举例：对于下面的document：

{...name: { first: "Alan", last: "Turing" },...
}

要访问name中的last字段，可以这样使用：

“name.last”

6> Documents限制
Documents有下面这些属性和限制：

Document大小限制
每个BSON文档的最大尺寸为16兆字节。

最大文档大小有助于确保一个单个文档不会使用过量的内存，或通信过程中过大的带宽占用。

若要存储超过最大尺寸的文档，MongoDB提供了GridFS API。可以看mongofiles和更多有关GridFS的文档

Document Field顺序
MongoDB中field的顺序默认是按照写操作的顺序来保存的，除了下面几种情况：

_id总是document的第一个field
可能会导致文档中的字段的重新排序的更新，包括字段名重命名。
在2.6版本起，MongoDB开始积极地尝试保留document中field的顺序。

_id字段
_id字段有以下行为和限制：

默认情况下，MongoDB会在创建collection时创建一个_id字段的唯一索引
_id字段总是documents中的第一个字段。如果服务器接收到一个docuement，它的第一个字段不是_id，那么服务器会将_id字段移在开头
_id字段可以是除了array数组之外的任何BSON数据格式
以下是存储_id值的常用选项：

• 使用ObjectId
• 最好使用自然的唯一标识符，可以节省空间并避免额外的索引
• 生成一个自动递增的数字。请参阅创建一个自动递增序列字段
• 在您的应用程序代码中生成UUID。为了更高效的在collection和_id索引中存储UUID值，可以用BSON的BinData类型存储UUID。

大部分MongoDB驱动客户端会包含_id字段，并且在发送insert操作的时候生成一个ObjectId。但是如果客户端发送一个不带_id字段的document，mongod会添加_id字段并产生一个ObjectId

5. MongoDB优化方式

- 性能与用户量

“如何能让软件拥有更高的性能？”，我想这是一个大部分开发者都思考过的问题。性能往往决定了一个软件的质量，如果你开发的是一个互联网产品，那么你的产品性能将更加受到考验，因为你面对的是广大的互联网用户，他们可不是那么有耐心的。严重点说，页面的加载速度每增加一秒也许都会使你失去一部分用户，也就是说，加载速度和用户量是成反比的。那么用户能够接受的加载速度到底是多少呢？

如图，如果页面加载时间超过10s那么用户就会离开，如果1s–10s的话就需要有提示，但如果我们的页面没有提示的话需要多快的加载速度呢？是的，1s 。

当然，这是站在一个产品经理的角度来说的，但如果站在一个技术人员的角度来说呢？加载速度和用户量就是成正比的，你的用户数量越多需要处理的数据当然也就越多，加载速度当然也就越慢。这是一件很有趣的事，所以如果你的产品如果是一件激动人心的产品，那么作为技术人员你需要做的事就是让软件的性能和用户的数量同时增长，甚至性能增长要快于用户量的增长。

数据库性能对软件整体性能的影响是不言而喻的，那么，当我们使用MongoDB时该如何提高数据库性能呢？

方案一：范式化与反范式化

- 什么是范式化与反范式化

• 范式化（normalization）是关系模型的发明者埃德加·科德于1970年提出这一概念，范式化会将数据分散到不同的表中，利用关系模型进行关联，由此带来的优点是，在后期进行修改时，不会影响到与其关联的数据，仅对自身修改即可完成。
• 反范式化（denormalization）是针对范式化提出的相反理念，反范式化会将当前文档的数据集中存放在本表中，而不会采用拆分的方式进行存储。
• 范式化和反范式化之间不存在优劣的问题，范式化的好处是可以在我们写入、修改、删除时的提供更高性能，而反范式化可以提高我们在查询时的性能。当然NoSQL中是不存在关联查询的，以此提高查询性能，但我们依旧可以以在表中存储关联表ID的方式进行范式化。但由此可见，NoSQL的理念中反范式化的地位是大于范式化的。

在项目设计阶段，明确集合的用途是对性能调优非常重要的一步。

从性能优化的角度来看，集合的设计我们需要考虑的是集合中数据的常用操作，例如我们需要设计一个日志（log）集合，日志的查看频率不高，但写入频率却很高，那么我们就可以得到这个集合中常用的操作是更新（增删改）。如果我们要保存的是城市列表呢？显而易见，这个集合是一个查看频率很高，但写入频率很低的集合，那么常用的操作就是查询。

对于频繁更新和频繁查询的集合，我们最需要关注的重点是他们的范式化程度，范式化与反范式化的合理运用对于性能的提高至关重要。然而这种设计的使用非常灵活，假设现在我们需要存储一篇图书及其作者，在MongoDB中的关联就可以体现为以下几种形式：

1. 完全分离（范式化设计）

示例1：

{"_id" : ObjectId("5124b5d86041c7dca81917"),"title" : "如何使用MongoDB", "author" : [ ObjectId("144b5d83041c7dca84416"),ObjectId("144b5d83041c7dca84418"),ObjectId("144b5d83041c7dca84420"),]}

我们将作者(comment) 的id数组作为一个字段添加到了图书中去。这样的设计方式是在非关系型数据库中常用的，也就是我们所说的范式化设计。在MongoDB中我们将与主键没有直接关系的图书单独提取到另一个集合，用存储主键的方式进行关联查询。当我们要查询文章和评论时需要先查询到所需的文章，再从文章中获取评论id，最后用获得的完整的文章及其评论。在这种情况下查询性能显然是不理想的。但当某位作者的信息需要修改时，范式化的维护优势就凸显出来了，我们无需考虑此作者关联的图书，直接进行修改此作者的字段即可。

2. 完全内嵌（反范式化设计）

示例2：

{"_id" : ObjectId("5124b5d86041c7dca81917"),"title" : "如何使用MongoDB","author" : [{"name" : "丁磊""age" : 40,"nationality" : "china",},{"name" : "马云""age" : 49,"nationality" : "china",},{"name" : "张召忠""age" : 59,"nationality" : "china",},]}

在这个示例中我们将作者的字段完全嵌入到了图书中去，在查询的时候直接查询图书即可获得所对应作者的全部信息，但因一个作者可能有多本著作，当修改某位作者的信息时时，我们需要遍历所有图书以找到该作者，将其修改。

3. 部分内嵌（折中方案）

示例3：

{"_id" : ObjectId("5124b5d86041c7dca81917"),"title" : "如何使用MongoDB","author" : [ {"_id" : ObjectId("144b5d83041c7dca84416"),"name" : "丁磊"},{"_id" : ObjectId("144b5d83041c7dca84418"),"name" : "马云"},{"_id" : ObjectId("144b5d83041c7dca84420"),"name" : "张召忠"},]}

这次我们将作者字段中的最常用的一部分提取出来。当我们只需要获得图书和作者名时，无需再次进入作者集合进行查询，仅在图书集合查询即可获得。

这种方式是一种相对折中的方式，既保证了查询效率，也保证的更新效率。但这样的方式显然要比前两种较难以掌握，难点在于需要与实际业务进行结合来寻找合适的提取字段。如同示例3所述，名字显然不是一个经常修改的字段，这样的字段如果提取出来是没问题的，但如果提取出来的字段是一个经常修改的字段（比如age）的话，我们依旧在更新这个字段时需要大范围的寻找并依此进行更新。

在上面三个示例中，第一个示例的更新效率是最高的，但查询效率是最低的，而第二个示例的查询效率最高，但更新效率最低。所以在实际的工作中我们需要根据自己实际的需要来设计表中的字段，以获得最高的效率。

方案二： 填充因子

何为填充因子？

填充因子（padding factor）是MongoDB为文档的扩展而预留的增长空间，因为MongoDB的文档是以顺序表的方式存储的，每个文档之间会非常紧凑，如图所示。

（注：图片出处：《MongoDB The Definitive Guide》）

1.元素之间没有多余的可增长空间。

　　

2.当我们对顺序表中某个元素的大小进行增长的时候，就会导致原来分配的空间不足，只能要求其向后移动。

3.当修改元素移动后，后续插入的文档都会提供一定的填充因子，以便于文档频繁的修改，如果没有不再有文档因增大而移动的话，后续插入的文档的填充因子会依此减小。

填充因子的理解之所以重要，是因为文档的移动非常消耗性能，频繁的移动会大大增加系统的负担，在实际开发中最有可能会让文档体积变大的因素是数组，所以如果我们的文档会频繁修改并增大空间的话，则一定要充分考虑填充因子。

那么如果我们的文档是个常常会扩展的话，应该如何提高性能？
两种方案

1.增加初始分配空间。在集合的属性中包含一个 usePowerOf2Sizes 属性，当这个选项为true时，系统会将后续插入的文档，初始空间都分配为2的N次方。

这种分配机制适用于一个数据会频繁变更的集合使用，他会给每个文档留有更大的空间，但因此空间的分配不会像原来那样高效，如果你的集合在更新时不会频繁的出现移动现象，这种分配方式会导致写入速度相对变慢。

2.我们可以利用数据强行将初始分配空间扩大。

1 db.book.insert({
2     "name" : "MongoDB",
3     "publishing" : "清华大学出版社",
4     "author" : "john"
5     "tags" : []
6     "stuff" : "ggggggggggggggggggggggggggggggggggggg
7                ggggggggggggggggggggggggggggggggggggg
8                ggggggggggggggggggggggggggggggggggggg"
9 })

是的，这样看起来可能不太优雅…但有时却很有效！当我们对这个文档进行增长式修改时，只要将stuff字段删掉即可。当然，这个stuff字段随便你怎么起名，包括里边的填充字符当然也是可以随意添加的。

方案三：利用索引

1.索引越少越好

索引可以极大地提高查询性能，那么索引是不是越多越好？答案是否定的，并且索引并非越多越好，而是越少越好。每当你建立一个索引时，系统会为你添加一个索引表，用于索引指定的列，然而当你对已建立索引的列进行插入或修改时，数据库则需要对原来的索引表进行重新排序，重新排序的过程非常消耗性能，但应对少量的索引压力并不是很大，但如果索引的数量较多的话对于性能的影响可想而知。所以在创建索引时需要谨慎建立索引，要把每个索引的功能都要发挥到极致，也就是说在可以满足索引需求的情况下，索引的数量越少越好。

1> 隐式索引

//建立复合索引
db.test.ensureIndex({"age": 1,"no": 1,"name": 1 })

我们在查询时可以迅速的将age,no字段进行排序，隐式索引指的是如果我们想要排序的字段包含在已建立的复合索引中则无需重复建立索引。

db.test.find().sort("age": 1,"no": 1)db.test.find().sort("age": 1)

如以上两个排序查询，均可使用上面的复合索引，而不需要重新建立索引。

2> . 翻转索引

//建立复合索引
db.test.ensureIndex({"age": 1})

翻转索引很好理解，就是我们在排序查询时无需考虑索引列的方向，例如这个例子中我们在查询时可以将排序条件写为"{‘age’: 0}"，依旧不会影响性能。

2. 索引列颗粒越小越好

什么叫颗粒越小越好？在索引列中每个数据的重复数量称为颗粒，也叫作索引的基数。如果数据的颗粒过大，索引就无法发挥该有的性能。例如，我们拥有一个"age"列索引，如果在"age"列中，20岁占了50%，如果现在要查询一个20岁，名叫"Tom"的人，我们则需要在表的50%的数据中查询，索引的作用大大降低。所以，我们在建立索引时要尽量将数据颗粒小的列放在索引左侧，以保证索引发挥最大的作用。

7. MongoDB应用之使用log4j实现http请求日志入mongodb

思路及解决方案：
第一步：
通过aop去切web层的controller实现，获取每个http的内容并通过log4j将日志内容写到应用服务器的文件系统中。缺点是我们在集群中部署应用之后，应用请求的日志被分散记录在了不同应用服务器的文件系统上，这样分散的存储并不利于我们对日志内容的检索。

第二步：
log4j提供的输出器实现自Appender接口，要自定义appender输出到MongoDB，只需要继承AppenderSkeleton类，实现其中append()、close()、requiresLayout()等方法

重写append函数要实现的内容是：

1. 根据log4j.properties中的配置创建mongodb连接
2. LoggingEvent提供getMessage()函数来获取日志消息
3. 往配置的记录日志的collection中插入日志消息
   重写close函数：关闭mongodb的