① mongoDB在java中怎么根据内嵌文档条件查询
建立SimpleTest.java，完成简单的mongoDB数据库操作 Mongo mongo = new Mongo(); 这样就创建了一个MongoDB的数据库连接对象，它默认连接到当前机器的localhost地址，端口是27017。 DB db = mongo.getDB(“test”); 这样就获得了一个test的数据库，如果mongoDB中没有创建这个数据库也是可以正常运行的。如果你读过上一篇文章就知道，mongoDB可以在没有创建这个数据库的情况下，完成数据的添加操作。当添加的时候，没有这个库，mongoDB会自动创建当前数据库。 得到了db，下一步我们要获取一个“聚集集合DBCollection”，通过db对象的getCollection方法来完成。 DBCollection users = db.getCollection("users"); 这样就获得了一个DBCollection，它相当于我们数据库的“表”。 查询所有数据 DBCursor cur = users.find(); while (cur.hasNext()) { System.out.println(cur.next()); } 完整源码 package com.hoo.test; import java.net.UnknownHostException; import com.mongodb.DB; import com.mongodb.DBCollection; import com.mongodb.DBCursor; import com.mongodb.Mongo; import com.mongodb.MongoException; impor... 建立SimpleTest.java，完成简单的mongoDB数据库操作
Mongo mongo = new Mongo();
这样就创建了一个MongoDB的数据库连接对象，它默认连接到当前机器的localhost地址，端口是27017。
DB db = mongo.getDB(“test”);
这样就获得了一个test的数据库，如果mongoDB中没有创建这个数据库也是可以正常运行的。如果你读过上一篇文章就知道，mongoDB可以在没有创建这个数据库的情况下，完成数据的添加操作。当添加的时候，没有这个库，mongoDB会自动创建当前数据库。
得到了db，下一步我们要获取一个“聚集集合DBCollection”，通过db对象的getCollection方法来完成。
DBCollection users = db.getCollection("users");
这样就获得了一个DBCollection，它相当于我们数据库的“表”。
查询所有数据
DBCursor cur = users.find();
while (cur.hasNext()) {
System.out.println(cur.next());
}
完整源码
package com.hoo.test;
import java.net.UnknownHostException;
import com.mongodb.DB;
import com.mongodb.DBCollection;
import com.mongodb.DBCursor;
import com.mongodb.Mongo;
import com.mongodb.MongoException;
import com.mongodb.util.JSON;
/**
* <b>function:</b>MongoDB 简单示例
* @author hoojo
* @createDate 2011-5-24 下午02:42:29
* @file SimpleTest.java
* @package com.hoo.test
* @project MongoDB
* @blog http
* @email [email protected]
* @version 1.0
*/
public class SimpleTest {
public static void main(String[] args) throws UnknownHostException, MongoException {
Mongo mg = new Mongo();
//查询所有的Database
for (String name : mg.getDatabaseNames()) {
System.out.println("dbName: " + name);
}
DB db = mg.getDB("test");
//查询所有的聚集集合
for (String name : db.getCollectionNames()) {
System.out.println("collectionName: " + name);
}
DBCollection users = db.getCollection("users");
//查询所有的数据
DBCursor cur = users.find();
while (cur.hasNext()) {
System.out.println(cur.next());
}
System.out.println(cur.count());
System.out.println(cur.getCursorId());
System.out.println(JSON.serialize(cur));
}
② java怎么做到使用mongodb来进行分组查询统
java操作mongodb进行查询，常用筛选条件的设置如下：
条件列表：
BasicDBList
condList
=
new
BasicDBList();
临时条件对象：
BasicDBObject
cond
=
null;
DBCollection
coll
=
db.getCollection("A");
1、$where
在某种应用场合，若要集合A查询文档且要满足文档中某些属性运算结果，可以编写一脚本函数用where进行设置，比如：
某集合中存放的用户信息，包括姓名、年龄、手机号、地址等，要筛选出年龄大于20且小于等于40的用户，我们可以这样：
String
ageStr
=
"function
(){return
parseFloat(this.age)
>
20
&&
parseFloat(this.age)
<=
40};";
cond
=
new
BasicDBObject();
cond.put("$where",ageStr);
放入条件列表
condList.add(cond);
2、$in
接1实例中，要查询年龄为23、40、50的用户信息，我们可以这样：
创建一个临时的条件列表对象，将条件值分别添加进去
BasicDBList
values
=
new
BasicDBList();
values.add(23);
values.add(40);
values.add(50);
cond
=
new
BasicDBObject();
cond.put("age",new
BasicDBObject("$in",values));
放入条件列表
condList.add(cond);
3、模糊匹配
接1实例中，要按照用户的姓名进行模糊查询，如：王，我们可以这样做：
使用不区分大小写的模糊查询
3.1完全匹配
③ java操作MongoDB使用强制索引的方法
DBCollection dbc = db.getCollection("role");
dbc.setHintFields(null);
虽然3.0以后版本中 DBCollection方法 已过时，可以将就用
直接用 $hint 操作符
db.users.find( { name: {}, $hint: { age : 1 } } )
参考地址
https://docs.mongodb.org/manual/reference/operator/meta/hint/#metaOp._S_hint
④ mongoDB在 java中的事务怎么实现
MongoDB自身是不提供事务处理的。如果要实现事务操作，必须自己写实现代码。
在为你的项目选定数据库的时候，要根据你的项目来量身选择。如果需要强事务操作的和数据一致性很高的地方，最好选择健壮的关系行数据库。
如果对事务处理要求不高，而对数据存取要求很高的，则选择非关系型数据库。
⑤ mongodb在java中怎么做修改操作
java 操作mongodb插入、读取、修改以及删除基础
本文主要讲述如何使用Java操作MongoDB以及了解MongoDB如何进行日常的数据库操作。文章内容如下：第一步：安装MongoDB无需太多的繁杂步骤，你只要在MongoDB官方网站查看安装说明，根据自己的操作系统进行选择适应的版本即可。第二步：启动MongoDB服务器这一步也很简单。运行mongod.exe文件里的bin文件夹（我使用的是Windows OS系统），并启动MongoDB服务器。在默认的情况下服务器将启动端口27017，你需要在安装过程中创建将数据存储在/data/db目录里。第三步：启动MongoDB shell指令你可以通过运行mongo.exe文件来启动MongoBD shell。第四步：利用MongoDB创建数据库利用MongoDB在MongoDB shell中输入以下内容建立一个名为“company”的数据库。use company 记住，除非你在MangoDB里保存了一些东西，否则它不会自动为你保存。使用下面的命令帮你查看可用的数据库，它会显示“company”尚未被创建。show dbs; 第五步：在MongoDB中保存数据使用下面的命令来保存employee 数据代表一个collection，将其命名为employees。employee = {name : "A", no : 1} db.employees.save(employee) 通过使用下面的命令来查看collection里的数据。db.users.find(); 如何使用Java操作MongoDB？下面是是一段简单的Java代码，你可以在这里获得mongo-java驱动。很简单，只需要使用下面的代码，重复上面的操作即可。package com.eviac.blog.mongo; import java.net.UnknownHostException; import com.mongodb.BasicDBObject; import com.mongodb.DB; import com.mongodb.DBCollection; import com.mongodb.DBCursor; import com.mongodb.Mongo; import com.mongodb.MongoException; public class MongoDBClient { public static void main(String[] args) { try { Mongo mongo = new Mongo("localhost", 27017); DB db = mongo.getDB("company"); DBCollection collection = db.getCollection("employees"); BasicDBObject employee = new BasicDBObject(); employee.put("name", "Hannah"); employee.put("no", 2); collection.insert(employee); BasicDBObject searchEmployee = new BasicDBObject(); searchEmployee.put("no", 2); DBCursor cursor = collection.find(searchEmployee); while (cursor.hasNext()) { System.out.println(cursor.next()); } System.out.println("The Search Query has Executed!"); } catch (UnknownHostException e) { e.printStackTrace(); } catch (MongoException e) { e.printStackTrace(); } } } 结果如下：{ "_id" : { "$oid" : "4fec74dc907cbe9445fd2d70"} , "name" : "Hannah" , "no" : 2} The Search Query has Executed! 小结：随着互联网Web2.0网站的兴起，非关系型的数据库现在成了一个极其热门的新领域，非关系数据库产品的发展也非常迅速。本文浅显的谈及了如何使用Java操作MongoDB以及了解MongoDB如何进行日常的数据库操作的问题。如果您是这方面的专家不妨与我们分享下。本文为CSDN编译整理，未经允许不得转载。
⑥ 如何用Java操作MongoDB
HelloWorld程序
学习任何程序的第一步，都是编写HelloWorld程序，我们也不例外，看下如何通过Java编写一个HelloWorld的程序。
首先，要通过Java操作Mongodb，必须先下载Mongodb的Java驱动程序，可以在这里下载。
新建立一个Java工程，将下载的驱动程序放在库文件路径下，程序代码如下：
packagecom.mkyong.core;
importjava.net.UnknownHostException;
importcom.mongodb.BasicDBObject;
importcom.mongodb.DB;
importcom.mongodb.DBCollection;
importcom.mongodb.DBCursor;
importcom.mongodb.Mongo;
importcom.mongodb.MongoException;
/**
*Java+MongoDBHelloworldExample
*
*/
publicclassApp{
publicstaticvoidmain(String[]args){
try{
//实例化Mongo对象，连接27017端口
Mongomongo=newMongo("localhost",27017);
//连接名为yourdb的数据库，假如数据库不存在的话，mongodb会自动建立
DBdb=mongo.getDB("yourdb");
//GetcollectionfromMongoDB,databasenamed"yourDB"
//从Mongodb中获得名为yourColleection的数据集合，如果该数据集合不存在，Mongodb会为其新建立
DBCollectioncollection=db.getCollection("yourCollection");
//使用BasicDBObject对象创建一个mongodb的document,并给予赋值。
BasicDBObjectdocument=newBasicDBObject();
document.put("id",1001);
document.put("msg","helloworldmongoDBinJava");
//将新建立的document保存到collection中去
collection.insert(document);
//创建要查询的document
BasicDBObjectsearchQuery=newBasicDBObject();
searchQuery.put("id",1001);
//使用collection的find方法查找document
DBCursorcursor=collection.find(searchQuery);
//循环输出结果
while(cursor.hasNext()){
System.out.println(cursor.next());
}
System.out.println("Done");
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(MongoExceptione){
e.printStackTrace();
}
}
}
最后，输出的结果为：
{"_id":{"$oid":"4dbe5596dceace565d229dc3"},
"id":1001,"msg":"helloworldmongoDBinJava"}
Done
在上面的例子中，演示了使用Java对Mongodb操作的重要方法和步骤，首先通过创建Mongodb对象，传入构造函数的参数是Mongodb的数据库所在地址和端口，然后使用
getDB方法获得要连接的数据库名，使用getCollection获得数据集合的名，然后通过新建立BasicDBObject对象去建立document,最后通过collection的insert方法，将建立的document保存到数据库中去。而collection的find方法，则是用来在数据库中查找document。
从Mongodb中获得collection数据集
在Mongodb中，可以通过如下方法获得数据库中的collection:
DBCollectioncollection=db.getCollection("yourCollection");如果你不知道collection的名称，可以使用db.getCollectionNames()获得集合，然后再遍历，如下：
DBdb=mongo.getDB("yourdb");
Setcollections=db.getCollectionNames();
for(StringcollectionName:collections){
System.out.println(collectionName);
}完成的一个例子如下：
packagecom.mkyong.core;
importjava.net.UnknownHostException;
importjava.util.Set;
importcom.mongodb.DB;
importcom.mongodb.DBCollection;
importcom.mongodb.Mongo;
importcom.mongodb.MongoException;
/**
*Java:GetcollectionfromMongoDB
*
*/
publicclassGetCollectionApp{
publicstaticvoidmain(String[]args){
try{
Mongomongo=newMongo("localhost",27017);
DBdb=mongo.getDB("yourdb");
Set<String>collections=db.getCollectionNames();
for(StringcollectionName:collections){
System.out.println(collectionName);
}
DBCollectioncollection=db.getCollection("yourCollection");
System.out.println(collection.toString());
System.out.println("Done");
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(MongoExceptione){
e.printStackTrace();
}
}
}
Mongodb中如何插入数据
下面，讲解下如何使用4种方式，将JSON数据插入到Mongodb中去。首先我们准备JSON
格式的数据，如下：
{
"database":"mkyongDB",
"table":"hosting",
"detail":
{
records:99,
index:"vps_index1",
active:"true"
}
}
}我们希望用不同的方式，通过JAVA代码向Mongodb插入以上格式的JSON数据
第一种方法，是使用BasicDBObject，方法如下代码所示：
BasicDBObjectdocument=newBasicDBObject();
document.put("database","mkyongDB");
document.put("table","hosting");
BasicDBObjectdocumentDetail=newBasicDBObject();
documentDetail.put("records","99");
documentDetail.put("index","vps_index1");
documentDetail.put("active","true");
document.put("detail",documentDetail);
collection.insert(document);
第二种方法是使用BasicDBObjectBuilder对象，如下代码所示：
=BasicDBObjectBuilder.start()
.add("database","mkyongDB")
.add("table","hosting");
Detail=BasicDBObjectBuilder.start()
.add("records","99")
.add("index","vps_index1")
.add("active","true");
documentBuilder.add("detail",documentBuilderDetail.get());
collection.insert(documentBuilder.get());
第三种方法是使用Map对象，代码如下：
MapdocumentMap=newHashMap();
documentMap.put("database","mkyongDB");
documentMap.put("table","hosting");
MapdocumentMapDetail=newHashMap();
documentMapDetail.put("records","99");
documentMapDetail.put("index","vps_index1");
documentMapDetail.put("active","true");
documentMap.put("detail",documentMapDetail);
collection.insert(newBasicDBObject(documentMap));
第四种方法，也就是最简单的，即直接插入JSON格式数据
String json="{'database' : 'mkyongDB','table' : 'hosting',"+
"'detail' : {'records' : 99, 'index' : 'vps_index1', 'active' : 'true'}}}";
DBObject dbObject=(DBObject)JSON.parse(json);
collection.insert(dbObject);
这里使用了JSON的parse方法，将解析后的JSON字符串转变为DBObject对象后再直接插入到collection中去。
完整的代码如下所示：
packagecom.mkyong.core;
importjava.net.UnknownHostException;
importjava.util.HashMap;
importjava.util.Map;
importcom.mongodb.BasicDBObject;
importcom.mongodb.BasicDBObjectBuilder;
importcom.mongodb.DB;
importcom.mongodb.DBCollection;
importcom.mongodb.DBCursor;
importcom.mongodb.DBObject;
importcom.mongodb.Mongo;
importcom.mongodb.MongoException;
importcom.mongodb.util.JSON;
/**
* Java MongoDB : Insert a Document
*
*/
publicclass InsertDocumentApp {
publicstaticvoid main(String[] args){
try{
Mongo mongo=newMongo("localhost",27017);
DB db=mongo.getDB("yourdb");
//get a single collection
DBCollection collection=db.getCollection("mmyColl");
//BasicDBObject example
System.out.println("BasicDBObject example...");
BasicDBObject document=newBasicDBObject();
document.put("database","mkyongDB");
document.put("table","hosting");
BasicDBObject documentDetail=newBasicDBObject();
documentDetail.put("records","99");
documentDetail.put("index","vps_index1");
documentDetail.put("active","true");
document.put("detail", documentDetail);
collection.insert(document);
DBCursor cursorDoc=collection.find();
while(cursorDoc.hasNext()){
System.out.println(cursorDoc.next());
}
collection.remove(newBasicDBObject());
//BasicDBObjectBuilder example
System.out.println("BasicDBObjectBuilder example...");
BasicDBObjectBuilder documentBuilder=BasicDBObjectBuilder.start()
.add("database","mkyongDB")
.add("table","hosting");
BasicDBObjectBuilder documentBuilderDetail=BasicDBObjectBuilder.start()
.add("records","99")
.add("index","vps_index1")
.add("active","true");
documentBuilder.add("detail", documentBuilderDetail.get());
collection.insert(documentBuilder.get());
DBCursor cursorDocBuilder=collection.find();
while(cursorDocBuilder.hasNext()){
System.out.println(cursorDocBuilder.next());
}
collection.remove(newBasicDBObject());
//Map example
System.out.println("Map example...");
Map documentMap=newHashMap();
documentMap.put("database","mkyongDB");
documentMap.put("table","hosting");
Map documentMapDetail=newHashMap();
documentMapDetail.put("records","99");
documentMapDetail.put("index","vps_index1");
documentMapDetail.put("active","true");
documentMap.put("detail", documentMapDetail);
collection.insert(newBasicDBObject(documentMap));
DBCursor cursorDocMap=collection.find();
while(cursorDocMap.hasNext()){
System.out.println(cursorDocMap.next());
}
collection.remove(newBasicDBObject());
//JSON parse example
System.out.println("JSON parse example...");
String json="{'database' : 'mkyongDB','table' : 'hosting',"+
"'detail' : {'records' : 99, 'index' : 'vps_index1', 'active' : 'true'}}}";
DBObject dbObject=(DBObject)JSON.parse(json);
collection.insert(dbObject);
DBCursor cursorDocJSON=collection.find();
while(cursorDocJSON.hasNext()){
System.out.println(cursorDocJSON.next());
}
collection.remove(newBasicDBObject());
}catch(UnknownHostException e){
e.printStackTrace();
}catch(MongoException e){
e.printStackTrace();
}
}
}
⑦ Mongodb在java中，多线程update时报错，请问是哪里出现的问题
不用设置mongodb的线程数，只需要把number变量的值设小一点就行了，比如10.
可以设置mongodb的连接池。试念液闭试这句话。 System.setProperty("MONGO.POOLSIZE",number);
MongoOptions options = mg.getMongoOptions();
options.autoConnectRetry = true;
options.connectionsPerHost =number; }
，不过仔裂一般使用默认的连埋察接池就够了，如果线程太多可能影响mongodb的效率。
⑧ java直接操作mongodb语句
参考如下
public class MongoDBJDBC {
public static void main(String[] args) {
try {
// 实例化Mongo对象，连接27017端口
Mongo mongo = new Mongo("localhost", 27017);
// 连接名为yourdb的数据库，假如数据库不存在的话，mongodb会自动建立
DB db = mongo.getDB("test");
// Get collection from MongoDB, database named "yourDB"
// 从Mongodb中获得名为yourColleection的数据集合，如果该数据集合不存在，Mongodb会为其新建立
DBCollection collection = db.getCollection("test1");
// 使用BasicDBObject对象创建一个mongodb的document,并给予赋值。
BasicDBObject document = new BasicDBObject();
//document.put("id", 1001);
//document.put("msg", "hello world mongoDB in Java");
// 将新建立的document保存到collection中去
//collection.insert(document);
// 创建要查询的document
BasicDBObject searchQuery = new BasicDBObject();
searchQuery.put("name", "chen");
// 使用collection的find方法查找document
DBCursor cursor = collection.find(searchQuery);
// 循环输出结果
while (cursor.hasNext()) {
System.out.println(cursor.next());
}
System.out.println("Hello World");
} catch (UnknownHostException e) {
e.printStackTrace();
} catch (MongoException e) {
e.printStackTrace();
}
}
}
⑨ MongoDB 是什么看完你就知道了
点击上方 蓝色字体 ，选择“置顶公众号”
优质文章，第一时间送达
链接 | blog.csdn.net/hayre/article/details/80628431
1.MongoDB是什么？用一句话总结
MongoDB是一款为web应用程序和互联网基础设施设计的数据库管理系统。没错MongoDB就是数据库，是NoSQL类型的数据库。
（1）MongoDB提出的是文档、集合的概念，使用BSON（类JSON）作为其数据模型结构，其结构是面向对象的而不是二维表，存储一个用户在MongoDB中是这样子的。
使用这样的数据模型，使得MongoDB能在生产环境中提供高读写的能力，吞吐量较于mysql等SQL数据库大大增强。
（2）易伸缩，自动故障转移。易伸缩指的是提供了分片能力，能对数据集进行分片，数据的存储压力分摊给多台服务器。自动故障转移是副本集的概念，MongoDB能检测主节点是否存活，当失活时能自动提升从节点为主节点，达到故障转移。
（3）数据模型因为是面向对象的，所以可以表示丰富的、有层级的数据结构，比如博客系统中能把“评论”直接怼到“文章“的文档中，而不必像myqsl一样创建三张表来描述这样的关系。
3.主要特性
（1）文档数据类型
SQL类型的数据库是正规化的，可以通过主键或者外键的约束保证数据的完整性与唯一性，所以SQL类型的数据库常用于对数据完整性较高的系统。MongoDB在这一方面是不如SQL类型的数据库，且MongoDB没有固定的Schema，正因为MongoDB少了一些这样的约束条件，可以让数据的存储数据结构更灵活，存储速度更加快。 （2）即时查询能力
MongoDB保留了关系型数据库即时查询的能力，保留了索引（底层是基于B tree）的能力。这一点汲取了关系型数据库的优点，相比于同类型的NoSQL redis 并没有上述的能力。 （3）复制能力
MongoDB自身提供了副本集能将数据分布在多台机器上实现冗余，目的是可以提供自动故障转移、扩展读能力。 （4）速度与持久性
MongoDB的驱动实现一个写入语义 fire and forget ，即通过驱动调用写入时，可以立即得到返回得到成功的结果（即使是报错），这样让写入的速度更加快，当然会有一定的不安全性，完全依赖网络。
MongoDB提供了Journaling日志的概念，实际上像mysql的bin-log日志，当需要插入的时候会先往日志里面写入记录，再完成实际的数据操作，这样如果出现停电，进程突然中断的情况，可以保障数据不会错误，可以通过修复功能读取Journaling日志进行修复。
（5）数据扩展
MongoDB使用分片技术对数据进行扩展，MongoDB能自动分片、自动转移分片里面的数据块，让每一个服务器里面存储的数据都是一样大小。
MongoDB核心服务器主要是通过mongod程序启动的，而且在启动时不需对MongoDB使用的内存进行配置，因为其设计哲学是内存管理最好是交给操作系统，缺少内存配置是MongoDB的设计亮点，另外，还可通过mongos路由服务器使用分片功能。
MongoDB的主要客户端是可以交互的js shell 通过mongo启动，使用js shell能使用js直接与MongoDB进行交流，像使用sql语句查询mysql数据一样使用js语法查询MongoDB的数据，另外还提供了各种语言的驱动包，方便各种语言的接入。
mongomp和mongorestore,备份和恢复数据库的标准工具。输出BSON格式，迁移数据库。
mongoexport和mongoimport，用来导入导出JSON、CSV和TSV数据，数据需要支持多格式时有用。mongoimport还能用与大数据集的初始导入，但是在导入前顺便还要注意一下，为了能充分利用好mongoDB通常需要对数据模型做一些调整。
mongosniff,网络嗅探工具，用来观察发送到数据库的操作。基本就是把网络上传输的BSON转换为易于人们阅读的shell语句。
因此，可以总结得到，MongoDB结合键值存储和关系数据库的最好特性。因为简单，所以数据极快，而且相对容易伸缩还提供复杂查询机制的数据库。MongoDB需要跑在64位的服务器上面，且最好单独部署，因为是数据库，所以也需要对其进行热备、冷备处理。
因为本篇文章不是API手册，所有这里对shell的使用也是基础的介绍什么功能可以用什么语句，主要是为了展示使用MongoDB shell的方便性，如果需要知道具体的MongoDB shell语法可以查阅官方文档。
创建数据库并不是必须的操作，数据库与集合只有在第一次插入文档时才会被创建，与对数据的动态处理方式是一致的。简化并加速开发过程，而且有利于动态分配命名空间。如果担心数据库或集合被意外创建，可以开启严格模式。
以上的命令只是简单实例，假设如果你之前没有学习过任何数据库语法，同时开始学sql查询语法和MongoDB 查询语法，你会发现哪一个更简单呢？如果你使用的是java驱动去操作MongoDB，你会发现任何的查询都像Hibernate提供出来的查询方式一样，只要构建好一个查询条件对象，便能轻松查询（接下来会给出示例），博主之前熟悉ES6，所以入手MongoDB js shell完成没问题，也正因为这样简洁，完善的查询机制，深深的爱上了MongoDB。
使用java驱动链接MongoDB是一件非常简单的事情，简单的引用，简单的做增删改查。在使用完java驱动后我才发现spring 对MongoDB 的封装还不如官方自身提供出来的东西好用，下面简单的展示一下使用。
这里只举例了简单的链接与简单的MongoDB操作，可见其操作的容易性。使用驱动时是基于TCP套接字与MongoDB进行通信的，如果查询结果较多，恰好无法全部放进第一服务器中，将会向服务器发送一个getmore指令获取下一批查询结果。
插入数据到服务器时间，不会等待服务器的响应，驱动会假设写入是成功的，实际是使用客户端生成对象id，但是该行为可以通过配置配置，可以通过安全模式开启，安全模式可以校验服务器端插入的错误。
要清楚了解MongoDB的基本数据单元。在关系型数据库中有带列和行的数据表。而MongoDB数据的基本单元是BSON文档，在键值中有指向不定类型值的键，MongoDB拥有即时查询，但不支持联结操作，简单的键值存储只能根据单个键来获取值，不支持事务，但支持多种原子更新操作。
如读写比是怎样的，需要何种查询，数据是如何更新的，会不会存在什么并发问题，数据结构化的程度是要求高还是低。系统本身的需求决定mysql还是MongoDB。
在关于schema 的设计中要注意一些原则，比如：
数据库是集合的逻辑与物理分组，MongoDB没有提供创建数据库的语法，只有在插入集合时，数据库才开始建立。创建数据库后会在磁盘分配一组数据文件，所有集合、索引和数据库的其他元数据都保存在这些文件中，查阅数据库使用磁盘状态可通过。
集合是结构上或概念上相似得文档的容器，集合的名称可以包含数字、字母或 . 符号，但必须以字母或数字开头，完全。
限定集合名不能超过128个字符，实际上 . 符号在集合中很有用，能提供某种虚拟命名空间，这是一种组织上的原则，和其他集合是一视同仁的。在集合中可以使用。
其次是键值，在MongoDB里面所有的字符串都是UTF-8类型。数字类型包括double、int、long。日期类型都是UTC格式，所以在MongoDB里面看到的时间会比北京时间慢8小时。整个文档大小会限制在16m以内，因为这样可以防止创建难看的数据类型，且小文档可以提升性能，批量插入文档理想数字范围是10~200，大小不能超过16MB。
（2）解析查询时MongoDB通过最优计划选择一个索引进行查询，当没有最适合索引时，会先不同的使用各个索引进行查询，最终选出一个最优索引做查询
（3）如果有一个a-b的复合索引，那么仅针对a的索引是冗余的
（4）复合索引里的键的顺序是很重要的
（2）复合索引
（3）唯一性索引
（4）稀疏索引
如索引的字段会出现的值，或是大量文档都不包含被索引的键。
如果数据集很大时，构建索引将会花费很长的时间，且会影响程序性能，可通过
当使用 mongorestore 时会重新构建索引。当曾经执行过大规模的删除时，可使用
对索引进行压缩，重建。
（1）查阅慢查询日志
（2）分析慢查询
注意新版本的MongoDB 的explain方法是需要参数的，不然只显示普通的信息。
本节同样主要简单呈现MongoDB副本集搭建的简易性，与副本集的强壮性，监控容易性
提供主从复制能力，热备能力，故障转移能力
实际上MongoDB对副本集的操作跟mysql主从操作是差不多的，先看一下mysql的主从数据流动过程
而MongoDB主要依赖的日志文件是oplog
写操作先被记录下来，添加到主节点的oplog里。与此同时，所有从结点复制oplog。首先，查看自己oplog里最后一条的时间戳；其次，查询主节点oplog里所有大于此时间戳的条目;最后，把那些条目添加到自己的oplog里并应用到自己的库里。从节点使用长轮询立即应用来自主结点oplog的新条目。
当遇到以下情况，从节点会停止复制
local数据库保存了所有副本集元素据和oplog日志
可以使用以下命令查看复制情况
每个副本集成员每秒钟ping一次其他所有成员，可以通过rs.status看到节点上次的心跳检测时间戳和 健康 状况。
这个点没必要过多描述，但是有一个特殊场景，如果从节点和仲裁节点都被杀了，只剩下主节点，他会把自己降级成为从节点。
如果主节点的数据还没有写到从库，那么数据不能算提交，当该主节点变成从节点时，便会触发回滚，那些没写到从库的数据将会被删除，可以通过rollback子目录中的BSON文件恢复回滚的内容。
只能链接到主节点，如果链接到从节点的话，会被拒绝写入操作，但是如果没有使用安全模式，因为mongo的fire and forget 特性，会把拒绝写入的异常给吃掉。
（2）使用副本集方式链接
能根据写入的情况自动进行故障转移，但是当副本集进行新的选举时，还是会出现故障，如果不使用安全模式，依旧会出现写不进去，但现实成功的情况。
分片是数据库切分的一个概念实现，这里也是简单总结为什么要使用分片以及分片的原理，操作。
当数据量过大，索引和工作数据集占用的内存就会越来越多，所以需要通过分片负载来解决这个问题
（2）分片的核心操作
分片一个集合：分片是根据一个属性的范围进行划分的，MongoDB使用所谓的分片键让每个文档在这些范围里找到自己的位置
块：是位于一个分片中的一段连续的分片键范围，可以理解为若干个块组成分片，分片组成MongoDB的全部数据
（3）拆分与迁移
块的拆分：初始化时只有一个块，达到最大块尺寸64MB或100000个文档就会触发块的拆分。把原来的范围一分为二，这样就有了两个块，每个块都有相同数量的文档。
迁移：当分片中的数据大小不一时会产生迁移的动作，比如分片A的数据比较多，会将分片A里面的一些块转移到分片B里面去。分片集群通过在分片中移动块来实现均衡，是由名为均衡器的软件进程管理的，任务是确保数据在各个分片中保持均匀分布，当集群中拥有块最多的分片与拥有块最少分片的块差大于8时，均衡器就会发起一次均衡处理。
启动两个副本集、三个配置服务器、一个mongos进程
配置分片
（2）索引
分片集合只允许在_id字段和分片键上添加唯一性索引，其他地方不行，因为这需要在分片间进行通信，实施起来很复杂。
当创建分片时，会根据分片键创建一个索引。
（2）低效的分片键
（3）理想的分片键
根据不同的数据中心划分
（2）最低要求
（3）配置的注意事项
需要估计集群大小，可使用以下命令对现有集合进行分片处理
（4）备份分片集群
备份分片时需要停止均衡器
使用64位机器、32位机器会制约mongodb的内存，使其最大值为1.5GB
（2）cpu mongodb 只有当索引和工作集都可放入内存时，才会遇到CPU瓶颈，CPU在mongodb使用中的作用是用来检索数据，如果看到CPU使用饱和的情况，可以通过查询慢查询日志，排查是不是查询的问题导致的，如果是可以通过添加索引来解决问题
mongodb写入数据时会使用到CPU，但是mongodb写入时间一次只用到一个核，如果有频繁的写入行为，可以通过分片来解决这个问题 （3）内存
大内存是mongodb的保障，如果工作集大小超过内存，将会导致性能下降，因为这将会增加数据加载入内存的动作
（4）硬盘
mongodb默认每60s会与磁盘强制同步一次，称为后台刷新，会产生I/O操作。在重启时mongodb会将磁盘里面的数据加载至内存，高速磁盘将会减少同步的时间
（5）文件系统
使用ext4 和 xfs 文件系统
禁用最后访问时间
（6）文件描述符
linux 默认文件描述符是1024，需要大额度的提升这个额度
（7）时钟
mongodb各个节点服务器之间使用ntp服务器
启动时使用 - -bind_ip 命令
（2）身份验证
启动时使用 - -auth 命令
（3）副本集身份认证
使用keyFile，注意keyFile文件的权限必须是600，不然会启动不起来
搭建副本集至少需要两个节点，其中仲裁结点不需要有自己的服务器
（2）Journaling日志 写数据时会先写入日志，而此时的数据也不是直接写入硬盘，而是写入内存
但是Journaling日志会消耗内存，所以可以在主库上面关闭，在从库上面启动
可以单独为Journaling日志使用一块固态硬盘
在插入时，可以通过驱动确保Journaling插入后再反馈，但是会非常影响性能。
-vvvvv 选项（v越多，输出越详细）
db.runCommand({logrotare:1}) 开启滚动日志
（2）top
（3）db.currentOp
动态展示mongodb活动数据
占用当前mongodb监听端口往上1000号的端口
把数据库内容导出成BSON文件，而mongorestore能读取并还原这些文件
（2）mongorestore
把导出的BSON文件还原到数据库
（3）备份原始数据文件 可以这么做，但是，操作之前需要进行锁库处理 db.runCommand({fsync:1,lock:true}) db.$cmd.sys.unlock.findOne 请求解锁操作，但是数据库不会立刻解锁，需要使用 db.currentOp 验证。
db.runCommand({repairDatabase:1}) 修复单个数据库
修复就是根据Jourling文件读取和重写所有数据文件并重建各个索引 （2）压紧
压紧，会重写数据文件，并重建集合的全部索引，需要停机或者在从库上面运行,如果需要在主库上面运行，需要添加force参数 保证加写锁。
（2）为提升性能检查索引和查询
总的来说，扫描尽可能少的文档。
保证没有冗余的索引，冗余的索引会占用磁盘空间、消耗更多的内存，在每次写入时还需做更多工作
（3）添加内存
dataSize 数据大小 和 indexSize 索引大小，如果两者的和大于内存，那么将会影响性能。
storageSize超过dataSize 数据大小 两倍以上，就会因磁盘碎片而影响性能，需要压缩。
⑩ 怎么使用java操作mongodb更新整个文档
上篇博客介绍了java操作mongoDB进行对文件的处理。现在来介绍一下对文档的处理。和对文件的处理一样，也是通过java驱动中提供的几个类相互作用完成的。这几个类分别是：
DBCollection类：指定数据库中指定集合的实例，提供了增删改查等一系列操作。在关系型数据库中，对数据的增删改查操作是建立在表的基础上的，在mongodb中是建立在集合的基础上进行的。
DBObject接口：DBObject是键值的映射，因此，可以将DBObject的实现类作为查询的返回结果，也可以作为查询条件
DBCursor：游标，返回结果的集合。
下面是部分实例：
[java] view plain
Mongo mongo = new Mongo();
DB db = mongo.getDB("myMongoDB");
DBCollection course = db.getCollection("course");//对myMongoDB数据库中course集合进行操作
//添加操作
//下面分别是创建文档的几种方式：1. .append() 2. .put() 3. 通过map 4. 将json转换成DBObject对象
DBObject english = new BasicDBObject().append("name","english").append("score", 5).append("id",1);
course.insert(english);
DBObject math = new BasicDBObject();
math.put("id", 2);
math.put("name", "math");
math.put("score", 10);
course.insert(math);
Map<String,Object> map = new HashMap<String,Object>();
map.put("name","physics" );
map.put("score", 10);
map.put("id", 3);
DBObject physics= new BasicDBObject(map);
course.insert(physics);
String json ="{'name':'chemistry','score':10,'id':4}";
DBObject chemistry =(DBObject)JSON.parse(json);
course.insert(chemistry);
List<DBObject> courseList = new ArrayList<DBObject>();
DBObject chinese = new BasicDBObject().append("name","chinese").append("score", 10).append("id", 5);
DBObject history = new BasicDBObject().append("name", "history").append("score", 10).append("id", 6);
courseList.add(chinese);
courseList.add(history);
course.insert(courseList);
//添加内嵌文档
String json2 =" {'name':'english','score':10,'teacher':[{'name':'柳松','id':'1'},{'name':'柳松松','id':2}]}";
DBObject english2= (DBObject)JSON.parse(json);
course.insert(english2);
List<DBObject> list = new ArrayList<DBObject>();
list.add(new BasicDBObject("name","柳松").append("id",1));
list.add(new BasicDBObject("name","柳松松").append("id",2));
DBObject english3= new BasicDBObject().append("name","english").append("score",10).append("teacher",list);
//查询
//查询所有、查询一个文档、条件查询
DBCursor cur = course.find();
while(cur.hasNext()){
DBObject document = cur.next();
System.out.println(document.get("name"));
}
DBObject document = course.findOne();
String name=(String)document.get("name");
System.out.println(name);
//查询学分=5的
DBObject query1 = new BasicDBObject("score",5);
DBObject query2 = new BasicDBObject("score",new BasicDBObject("$gte",5));
DBCursor cur2 = course.find(query2);
//条件表达式：$ge(>) $get(>=) $lt(<) $lte(<=) $ne(<>) $in $nin $all $exists $or $nor $where $type等等
//查找并修改
DBObject newDocument = course.findAndModify(new BasicDBObject("score",5), new BasicDBObject("score",15));
//更新操作
//q：更新条件 o:更新后的对象
course.update(new BasicDBObject("score",10), new BasicDBObject("test",15));
course.update(new BasicDBObject("score",15), new BasicDBObject("$set",new BasicDBObject("isRequired",true)));
//两个的区别是，第一个更新是将{"test":15}这个文档替换原来的文档，
//第二个更新添加了条件表达式$set，是在原来文档的基础上添加"isRequired"这个键
//条件表达式：$set $unset $push $inc $push $push $addToSet $pull $pullAll $pop等等
//当_id相同时，执行save方法相当于更新操作
course.save(new BasicDBObject("name","math").append("_id", 1));
course.save(new BasicDBObject("name","数学").append("_id", 1));
//删除符合条件的文档
course.remove(new BasicDBObject("score",15));
//删除集合及所有文档
course.drop();<span style="font-family:Arial, Helvetica, sans-serif;"><span style="white-space: normal;">
</span></span>
上面只是介绍了一些简单的操作，具体复杂的查询更新可以根据需求再去查找文档资料。其实，不管操作简单还是复杂，其核心都是对DBObject和DBCollection的操作，主要掌握DBObject如何构造键值对，以及一些条件表达式。