『壹』 怎麼使用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如何構造鍵值對，以及一些條件表達式。
『貳』 Mongodb的java driver中的Mongo和MongoClient有什麼區別
「MongoClient加入到Java驅動程序在2.10作為MongoDB的默認連接類其實並沒有什麼區別不過有時候Mongo運行得比MongoClient要快你可以試一下這個代碼，放入1m的文檔。Mongo大概用20秒左右，MongoClient要用180秒左右。替換mongo_connect:fun
『叄』 java鏈接mongo資料庫需要引什麼jar包
需要的jar
mongo-java-driver
maven倉庫裡面,mongodb3.0的連接驅動
<!--MongoDB資料庫連接驅動-->
<dependency>
<groupId>org.mongodb</groupId>
<artifactId>mongo-java-driver</artifactId>
<version>3.0.0</version>
</dependency>
2.連接過程代碼
importorg.bson.Document;
importcom.mongodb.MongoClient;
importcom.mongodb.client.MongoCollection;
importcom.mongodb.client.MongoDatabase;
/**
*2016年8月5日下午3:19:44
*
*@author3306TODO測試Mongo資料庫連接
*
*/
publicclassTestMongo{
;
privatestaticStringhost="192.168.0.149";//mongo資料庫伺服器地址,本地為127.0.0.1
privatestaticintport=20000;//mongo默認為27017埠
/**
*獲取資料庫集合
*
*@paramdatabaseName
*資料庫名稱
*@paramcollectionName
*集合名稱
*@returnMongoCollection<Document>
*/
publicstaticMongoCollection<Document>getMongoCollection(StringdatabaseName,StringcollectionName){
returngetMongoDatabase(databaseName).getCollection(collectionName);
}
/**
*獲取mongo資料庫
*
*@paramdatabaseName
*資料庫名稱
*@returnMongoDatabase
*/
(StringdatabaseName){
mongoClient=newMongoClient(host,port);
returnmongoClient.getDatabase(databaseName);
}
/**
*測試數據連接
*
*@paramargs
*/
publicstaticvoidmain(String[]args){
StringdatabaseName="mojing";//資料庫
StringcollectionName="user";//集合名稱
MongoCollection<Document>userCollection=getMongoCollection(databaseName,collectionName);
System.out.println(userCollection.count());
}
}
『肆』 java怎麼連接mangodb需要哪些步驟
開發環境：
System：Win7
IDE：eclipse
Database：mongoDB
開發依賴庫：
JavaEE5、mongo-2.5.3.jar、junit.jar、org.hamcrest.core_1.1.0.v20090501071000.jar
一、准備工作
1、下載Mongodb對java支持jar包
jar包下載地址：
mongoDB對Java的相關支持、技術：http://www.mongodb.org/display/DOCS/Java+Language+Center
驅動源碼下載：https://download.github.com/mongodb-mongo-java-driver-r2.6.1-7-g6037357.zip
在線查看源碼：https://github.com/mongodb/mongo-java-driver
2、下面建立一個JavaProject工程，導入下載下來的驅動包。即可在Java中使用mongoDB，目錄如下：
二、Java操作MongoDB示例
在本示例之前你需要啟動mongod.exe的服務，啟動後，下面的程序才能順利執行；
1、建立simpleTest.java，完成簡單的mongoDB資料庫操作
Mongomongo=newMongo();
這樣就創建了一個MongoDB的資料庫連接對象，它默認連接到當前機器的localhost地址，埠是27017。
DBdb=mongo.getDB(「test」);
這樣就獲得了一個test的資料庫，如果mongoDB中沒有創建這個資料庫也是可以正常運行的。mongoDB可以在沒有創建這個資料庫的情況下，完成數據的添加操作。當添加的時候，沒有這個庫，mongoDB會自動創建當前資料庫。
得到了db，下一步我們要獲取一個「聚集集合DBCollection」，通過db對象的getCollection方法來完成。
DBCollectionusers=db.getCollection("users");
這樣就獲得了一個DBCollection，它相當於我們資料庫的「表」。
查詢所有數據：
DBCursorcur=users.find();
while(cur.hasNext()){
System.out.println(cur.next());
}
完整源碼：
packagecom.mongodb;
importjava.net.UnknownHostException;
importcom.mongodb.util.JSON;
publicclasssimpleTest{
publicstaticvoidmain(String[]args)throwsUnknownHostException,MongoException{
Mongomg=newMongo();
//查詢所有的Database
for(Stringname:mg.getDatabaseNames()){
System.out.println("dbName:"+name);
}
DBdb=mg.getDB("test");
//查詢所有的聚集集合
for(Stringname:db.getCollectionNames()){
System.out.println("collectionName:"+name);
}
DBCollectionusers=db.getCollection("users");
//查詢所有的數據
DBCursorcur=users.find();
while(cur.hasNext()){
System.out.println("while="+cur.next());
}
System.out.println("count="+cur.count());
System.out.println("CursorId="+cur.getCursorId());
System.out.println("cur="+JSON.serialize(cur));
}
}
2、完成CRUD操作，首先建立一個curdTset.java，基本測試代碼如下：
packagecom.mongodb;
importjava.net.UnknownHostException;
importjava.util.ArrayList;
importjava.util.List;
importorg.bson.types.ObjectId;
importorg.junit.After;
importorg.junit.Before;
importorg.junit.Test;
importcom.mongodb.util.JSON;
publicclasscurdTset{
privateMongomg=null;
privateDBdb;
privateDBCollectionusers;//連接的mongodb資料庫
@Before
publicvoidinit(){
System.out.println("TestBefore...");
try{
mg=newMongo();
//mg=newMongo("localhost",27017);
}catch(UnknownHostExceptione){
e.printStackTrace();
}catch(MongoExceptione){
e.printStackTrace();
}catch(Exceptione){
e.printStackTrace();
}
//獲取testDB；如果默認沒有創建，mongodb會自動創建
db=mg.getDB("test");
//獲取usersDBCollection；如果默認沒有創建，mongodb會自動創建
users=db.getCollection("users");
}
@After
publicvoiddestory(){
System.out.println("TestAfter...");
if(mg!=null){
mg.close();
}
mg=null;
db=null;
users=null;
System.gc();
}
publicvoidprint(Objecto){
System.out.println(o);
}
privatevoidqueryAll(){
print("查詢users的所有數據：");
//db游標
DBCursorcur=users.find();
inti=1;
while(cur.hasNext()){
print("記錄"+i+":"+cur.next());
i++;
}
}
@Test
publicvoidadd(){
//先查詢所有數據
queryAll();
System.out.println("===============================ADDstart=======================================");
print("ADDcount:"+users.count());
DBObjectuser=newBasicDBObject();
user.put("name","hoojo");
user.put("age",24);
user.put("sex","男");
print(users.save(user).getN());
//添加多條數據，傳遞Array對象
print(users.insert(user,newBasicDBObject("name","tom")).getN());
//添加List集合
Listlist=newArrayList();
list.add(user);
DBObjectuser2=newBasicDBObject("name","lucy");
user.put("age",22);
list.add(user2);
//添加List集合
print(users.insert(list).getN());
//查詢下數據，看看是否添加成功
print("count="+users.count());
System.out.println("===============================ADDend=======================================");
//查詢所有數據
queryAll();
}
@Test
publicvoidremove(){
queryAll();
print("刪除id=4dde2b06feb038463ff09042："+users.remove(newBasicDBObject("_id",newObjectId("4dde2b06feb038463ff09042"))).getN());
print("removeage>=24:"+users.remove(newBasicDBObject("age",newBasicDBObject("$gte",24))).getN());
System.out.println("===============================REMOVEend=======================================");
//查詢所有數據
queryAll();
}
@Test
publicvoidmodify(){
print("修改："+users.update(newBasicDBObject("_id",newObjectId("4dde25d06be7c53ffbd70906")),newBasicDBObject("age",99)).getN());
print("修改："+users.update(
newBasicDBObject("_id",newObjectId("4dde2b06feb038463ff09042")),
newBasicDBObject("age",121),
true,//如果資料庫不存在，是否添加
false//多條修改
).getN());
print("修改："+users.update(
newBasicDBObject("name","haha"),
newBasicDBObject("name","dingding"),
true,//如果資料庫不存在，是否添加
false//false只修改第一條，true如果有多條就不修改
).getN());
//當資料庫不存在就不修改、不添加數據，當多條數據就不修改
//print("修改多條："+coll.updateMulti(newBasicDBObject("_id",newObjectId("4dde23616be7c19df07db42c")),newBasicDBObject("name","199")));
System.out.println("===============================EDITend=======================================");
//查詢所有數據
queryAll();
}
@Test
publicvoidtestOthers(){
//查詢所有數據
queryAll();
DBObjectuser=newBasicDBObject();
user.put("name","hoojo");
user.put("age",24);
//JSON對象轉換
print("serialize:"+JSON.serialize(user));
//反序列化
print("parse:"+JSON.parse("{"name":"hoojo","age":24}"));
print("判斷tempCollection是否存在:"+db.collectionExists("users"));
//如果不存在就創建
if(!db.collectionExists("users")){
DBObjectoptions=newBasicDBObject();
options.put("size",20);
options.put("capped",20);
options.put("max",20);
print(db.createCollection("account",options));
}
//設置db為只讀
db.setReadOnly(true);
//只讀不能寫入數據
db.getCollection("test").save(user);
}
}
『伍』 如何用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();
}
}
}