Mongodb快速入门之使用Java操作Mongodb

最新推荐文章于 2024-06-02 23:52:00 发布
最新推荐文章于 2024-06-02 23:52:00 发布
阅读量696 收藏 2
点赞数
分类专栏： MongDB 文章标签： mongodb java json database query 数据库

Mongodb快速入门之使用Java操作Mongodb

2011年06月20日00:00  it168网站原创 作者：廖煜嵘/译 编辑： 董建伟 评论： 1条

　　【IT168 专稿】在上一篇文章中，我们学习了Mongodb的安装和初步使用，在本文中，将学习如何使用Java去编程实现对Mongodb的操作。

　　HelloWorld程序

　　学习任何程序的第一步，都是编写HelloWorld程序，我们也不例外，看下如何通过Java编写一个HelloWorld的程序。

　　首先，要通过Java操作Mongodb，必须先下载Mongodb的Java驱动程序，可以在这里下载。

　　新建立一个Java工程，将下载的驱动程序放在库文件路径下，程序代码如下：

package  com.mkyong.core;
 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;

 /**
* Java + MongoDB Hello world Example
* 
 */
public   class  App {
     public   static   void  main(String[] args) {
         try  {
             // 实例化Mongo对象，连接27017端口
            Mongo mongo  =   new  Mongo( " localhost " ,  27017 );
                                // 连接名为yourdb的数据库，假如数据库不存在的话，mongodb会自动建立
            DB db  =  mongo.getDB( " yourdb " );
             //  Get collection from MongoDB, database named "yourDB"
 // 从Mongodb中获得名为yourColleection的数据集合，如果该数据集合不存在，Mongodb会为其新建立
            DBCollection collection  =  db.getCollection( " yourCollection " );
     //  使用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( " id " ,  1001 );
             //  使用collection的find方法查找document
            DBCursor cursor  =  collection.find(searchQuery);
             // 循环输出结果
             while  (cursor.hasNext()) {
            System.out.println(cursor.next());
            }
            System.out.println( " Done " ); 
        }  catch  (UnknownHostException e) {
            e.printStackTrace();
        }  catch  (MongoException e) {
            e.printStackTrace();
        }
    }
}

　　最后，输出的结果为：

{  " _id "  : {  " $oid "  :  " 4dbe5596dceace565d229dc3 " } , 
                 " id "  :  1001  ,  " msg "  :  " hello world mongoDB in Java " }
Done

　　在上面的例子中，演示了使用Java对Mongodb操作的重要方法和步骤，首先通过创建Mongodb对象，传入构造函数的参数是Mongodb的数据库所在地址和端口，然后使用

　　getDB方法获得要连接的数据库名，使用getCollection获得数据集合的名，然后通过新建立BasicDBObject对象去建立document,最后通过collection的insert方法，将建立的document保存到数据库中去。而collection的find方法，则是用来在数据库中查找document。

　　从Mongodb中获得collection数据集

　　在Mongodb中，可以通过如下方法获得数据库中的collection:

　　DBCollection collection  =  db.getCollection( " yourCollection " );

　　如果你不知道collection的名称，可以使用db.getCollectionNames()获得集合，然后再遍历，如下：

　　DB db  =  mongo.getDB( " yourdb " );
　　Set collections  =  db.getCollectionNames();
　　 for (String collectionName : collections){
　　System.out.println(collectionName);
　　}

　　完成的一个例子如下：

package  com.mkyong.core;
 import  java.net.UnknownHostException;
 import  java.util.Set;
 import  com.mongodb.DB;
 import  com.mongodb.DBCollection;
 import  com.mongodb.Mongo;
 import  com.mongodb.MongoException;
 /**
* Java : Get collection from MongoDB
* 
 */
public   class  GetCollectionApp {
 public   static   void  main(String[] args) {
 try  {
Mongo mongo  =   new  Mongo( " localhost " ,  27017 );
DB db  =  mongo.getDB( " yourdb " );
Set < String >  collections  =  db.getCollectionNames();
 for  (String collectionName : collections) {
System.out.println(collectionName);
}
DBCollection collection  =  db.getCollection( " yourCollection " );
System.out.println(collection.toString());
System.out.println( " Done " );

}  catch  (UnknownHostException e) {
e.printStackTrace();
}  catch  (MongoException e) {
e.printStackTrace();
}
}
}

　　Mongodb中如何插入数据

　　下面，讲解下如何使用4种方式，将JSON数据插入到Mongodb中去。首先我们准备JSON

　　格式的数据，如下：

　　{
　　 " database "  :  " mkyongDB " ,
　　 " table "  :  " hosting " ,
　　 " detail "  :
　　{
　　records :  99 ,
　　index :  " vps_index1 " ,
　　active :  " true "
　　}
　　}
　　}

　　我们希望用不同的方式，通过JAVA代码向Mongodb插入以上格式的JSON数据

　　第一种方法，是使用BasicDBObject，方法如下代码所示：

BasicDBObject document  =   new  BasicDBObject();
document.put( " database " ,  " mkyongDB " );
document.put( " table " ,  " hosting " );
BasicDBObject documentDetail  =   new  BasicDBObject();
documentDetail.put( " records " ,  " 99 " );
documentDetail.put( " index " ,  " vps_index1 " );
documentDetail.put( " active " ,  " true " );
document.put( " detail " , documentDetail);
collection.insert(document);

　　第二种方法是使用BasicDBObjectBuilder对象，如下代码所示：

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

　　第三种方法是使用Map对象，代码如下：

　　Map documentMap  = new  HashMap();
　　documentMap.put( " database " ,  " mkyongDB " );
　　documentMap.put( " table " ,  " hosting " );
　　Map documentMapDetail  = new  HashMap();
　　documentMapDetail.put( " records " ,  " 99 " );
　　documentMapDetail.put( " index " ,  " vps_index1 " );
　　documentMapDetail.put( " active " ,  " true " );
　　documentMap.put( " detail " , documentMapDetail);
　　collection.insert( new  BasicDBObject(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  = new  Mongo( " localhost " ,  27017 );
　　DB db  =  mongo.getDB( " yourdb " );
　　 //  get a single collection
　　DBCollection collection  =  db.getCollection( " dummyColl " );
　　 //  BasicDBObject example
　　System.out.println( " BasicDBObject example... " );
　　BasicDBObject document  = new  BasicDBObject();
　　document.put( " database " ,  " mkyongDB " );
　　document.put( " table " ,  " hosting " );
　　BasicDBObject documentDetail  = new  BasicDBObject();
　　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( new  BasicDBObject());
　　 //  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( new  BasicDBObject());
　　 //  Map example
　　System.out.println( " Map example... " );
　　Map documentMap  = new  HashMap();
　　documentMap.put( " database " ,  " mkyongDB " );
　　documentMap.put( " table " ,  " hosting " );
　　Map documentMapDetail  = new  HashMap();
　　documentMapDetail.put( " records " ,  " 99 " );
　　documentMapDetail.put( " index " ,  " vps_index1 " );
　　documentMapDetail.put( " active " ,  " true " );
　　documentMap.put( " detail " , documentMapDetail);
　　collection.insert( new  BasicDBObject(documentMap));
　　DBCursor cursorDocMap  =  collection.find();
　　 while (cursorDocMap.hasNext()){
　　System.out.println(cursorDocMap.next());
　　}
　　collection.remove( new  BasicDBObject());
　　 //  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( new  BasicDBObject());
　　} catch (UnknownHostException e){
　　e.printStackTrace();
　　} catch (MongoException e){
　　e.printStackTrace();
　　}
　　}
　　}

　　更新Document

　　假设如下的JSON格式的数据已经保存到Mongodb中去了，现在要更新相关的数据。

　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostA "  ,  " type "  :  " vps "  ,  " clients "  :  1000 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostB "  ,  " type "  :  " dedicated server "  ,  " clients "  :  100 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostC "  ,  " type "  :  " vps "  ,  " clients "  :  900 }

 　　假设现在要将hosting中值为hostB的进行更新，则可以使用如下的方法：

　　BasicDBObject newDocument  = new  BasicDBObject();
　　newDocument.put( " hosting " ,  " hostB " );
　　newDocument.put( " type " ,  " shared host " );
　　newDocument.put( " clients " ,  111 );
　　collection.update( new  BasicDBObject().append( " hosting " ,  " hostB " ), newDocument);

 　　可以看到，这里依然使用了BasicDBObject对象，并为其赋值了新的值后，然后使用collection的update方法，即可更新该对象。

　　更新后的输出如下：

　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostA "  ,  " type "  :  " vps "  ,  " clients "  :  1000 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostB "  ,  " type "  :  " shared host "  ,  " clients "  :  111 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostC "  ,  " type "  :  " vps "  ,  " clients "  :  900 }

 　　另外，还可以使用mongodb中的$inc修饰符号去对某个值进行更新，比如，要将hosting值为hostB的document的clients的值得更新为199(即100+99=199)，可以这样：

　　BasicDBObject newDocument  = new  BasicDBObject().append( " $inc " ,
　　 new  BasicDBObject().append( " clients " ,  99 ));
　　collection.update( new  BasicDBObject().append( " hosting " ,  " hostB " ), newDocument);

 　　则输出如下：

　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostA "  ,  " type "  :  " vps "  ,  " clients "  :  1000 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostB "  ,  " type "  :  " dedicated server "  ,  " clients "  :  199 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostC "  ,  " type "  :  " vps "  ,  " clients "  :  900 }

 　　接下来，讲解$set修饰符的使用。比如要把hosting中值为hostA的document中的

　　type的值进行修改，则可以如下实现：

　　BasicDBObject newDocument3  = new  BasicDBObject().append( " $set " ,
　　 new  BasicDBObject().append( " type " ,  " dedicated server " ));
　　collection.update( new  BasicDBObject().append( " hosting " ,  " hostA " ), newDocument3);

 　　则输出如下，把type的值从vps改为dedicated server:

　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostB "  ,  " type "  :  " dedicated server "  ,  " clients "  :  100 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostC "  ,  " type "  :  " vps "  ,  " clients "  :  900 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostA "  ,  " clients "  :  1000  ,  " type "  :  " dedicated server " }

 　　要注意的是，如果不使用$set的修饰符，而只是如下代码：

　　BasicDBObject newDocument3  = new  BasicDBObject().append( " type " ,  " dedicated server " );
　　collection.update( new  BasicDBObject().append( " hosting " ,  " hostA " ), newDocument3);

 　　则会将所有的三个document的type类型都改为dedicated server了，因此要使用$set以更新特定的document的特定的值。

　　如果要更新多个document中相同的值，可以使用$multi，比如，要把所有vps为type的document,将它们的clients的值更新为888，可以如下实现：

　　BasicDBObject updateQuery  = new  BasicDBObject().append( " $set " ,
　　 new  BasicDBObject().append( " clients " ,  " 888 " ));
　　collection.update( new  BasicDBObject().append( " type " ,  " vps " ), updateQuery,  false ,  true );
 

　　输出如下：

　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostA "  ,  " clients "  :  " 888 "  ,  " type "  :  " vps " }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostB "  ,  " type "  :  " dedicated server "  ,  " clients "  :  100 }
　　{ " _id "  : { " $oid "  :  " x " } ,  " hosting "  :  " hostC "  ,  " clients "  :  " 888 "  ,  " type "  :  " vps " }

　　最后，还是给出更新document的完整例子：

　　 package  com.liao;
　　 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;
　　publicclass UpdateDocumentApp {
　　publicstaticvoid printAllDocuments(DBCollection collection){
　　DBCursor cursor  =  collection.find();
　　 while  (cursor.hasNext()) {
　　System.out.println(cursor.next());
　　}
　　}
　　publicstaticvoid removeAllDocuments(DBCollection collection){
　　collection.remove( new  BasicDBObject());
　　}
　　publicstaticvoid insertDummyDocuments(DBCollection collection){
　　BasicDBObject document  =   new  BasicDBObject();
　　document.put( " hosting " ,  " hostA " );
　　document.put( " type " ,  " vps " );
　　document.put( " clients " ,  1000 );
　　BasicDBObject document2  =   new  BasicDBObject();
　　document2.put( " hosting " ,  " hostB " );
　　document2.put( " type " ,  " dedicated server " );
　　document2.put( " clients " ,  100 );
　　BasicDBObject document3  =   new  BasicDBObject();
　　document3.put( " hosting " ,  " hostC " );
　　document3.put( " type " ,  " vps " );
　　document3.put( " clients " ,  900 );
　　collection.insert(document);
　　collection.insert(document2);
　　collection.insert(document3);
　　}
　　publicstaticvoid main(String[] args) {
　　 try  {
　　Mongo mongo  =   new  Mongo( " localhost " ,  27017 );
　　DB db  =  mongo.getDB( " yourdb " );
　　DBCollection collection  =  db.getCollection( " dummyColl " );
　　System.out.println( " Testing 1... " );
　　insertDummyDocuments(collection);
　　 // find hosting = hostB, and update it with new document
　　BasicDBObject newDocument  =   new  BasicDBObject();
　　newDocument.put( " hosting " ,  " hostB " );
　　newDocument.put( " type " ,  " shared host " );
　　newDocument.put( " clients " ,  111 );
　　collection.update( new  BasicDBObject().append( " hosting " ,  " hostB " ), newDocument);
　　printAllDocuments(collection);
　　removeAllDocuments(collection);
　　System.out.println( " Testing 2... " );
　　insertDummyDocuments(collection);
　　BasicDBObject newDocument2  =   new  BasicDBObject().append( " $inc " ,
　　 new  BasicDBObject().append( " clients " ,  99 ));
　　collection.update( new  BasicDBObject().append( " hosting " ,  " hostB " ), newDocument2);
　　printAllDocuments(collection);
　　removeAllDocuments(collection);
　　System.out.println( " Testing 3... " );
　　insertDummyDocuments(collection);
　　BasicDBObject newDocument3  =   new  BasicDBObject().append( " $set " ,
　　 new  BasicDBObject().append( " type " ,  " dedicated server " ));
　　collection.update( new  BasicDBObject().append( " hosting " ,  " hostA " ), newDocument3);
　　printAllDocuments(collection);
　　removeAllDocuments(collection);
　　System.out.println( " Testing 4... " );
　　insertDummyDocuments(collection);
　　BasicDBObject updateQuery  =   new  BasicDBObject().append( " $set " ,
　　 new  BasicDBObject().append( " clients " ,  " 888 " ));
　　collection.update(
　　 new  BasicDBObject().append( " type " ,  " vps " ), updateQuery,  false ,  true );
　　printAllDocuments(collection);
　　removeAllDocuments(collection);
　　System.out.println( " Done " );
　　}  catch  (UnknownHostException e) {
　　e.printStackTrace();
　　}  catch  (MongoException e) {
　　e.printStackTrace();
　　}
　　}
　　}

　　查询Document

　　下面学习如何查询document,先用下面的代码往数据库中插入1-10数字：

　　 for ( int  i = 1 ; i  <= 10 ; i ++ ){
　　collection.insert( new  BasicDBObject().append( " number " , i));

　　}

 　　接下来，看下如下的例子：

　　1) 获得数据库中的第一个document:

　　DBObject doc  =  collection.findOne();
　　System.out.println(dbObject);

 　　输出为：

　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80bd " } ,  " number "  :  1 }

 　　2)获得document的集合

　　DBCursor cursor  =  collection.find();
　　 while (cursor.hasNext()){
　　System.out.println(cursor.next());
　　}

 　　这里，使用collection.find()方法，获得当前数据库中所有的documents对象集合

　　然后通过对DBCursor对象集合的遍历，即可输出当前所有documents。输出如下：

　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80bd " } ,  " number "  :  1 }
　　 // ..........中间部分省略，为2到9的输出
　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c6 " } ,  " number "  :  10 }

 　　3) 获取指定的document

　　比如要获得number=5的document对象内容，可以使用collection的find方法即可，如下：

　　BasicDBObject query  = new  BasicDBObject();
　　query.put( " number " ,  5 );
　　DBCursor cursor  =  collection.find(query);
　　 while (cursor.hasNext()){
　　System.out.println(cursor.next());
　　}

 　　即输出：

　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c1 " } ,  " number "  :  5 }

 　　4) 使用in操作符号

　　在mongodb中，也可以使用in操作符，比如要获得number=9和number=10的document对象，可以如下操作：

　　BasicDBObject query  = new  BasicDBObject();
　　List list  = new  ArrayList();
　　list.add( 9 );
　　list.add( 10 );
　　query.put( " number " ,  new  BasicDBObject( " $in " , list));
　　DBCursor cursor  =  collection.find(query);
　　 while (cursor.hasNext()){
　　System.out.println(cursor.next());
　　}

 　　这里使用了一个List，并将list传入到BasicDBObject的构造函数中，并使用了in操作符号，输出如下：

　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c5 " } ,  " number "  :  9 }
　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c6 " } ,  " number "  :  10 }

　　5) 使用>,<等比较符号

　　在mongodb中，也可以使用比如>,<等数量比较符号，比如要输出number>5的document集合，则使用“$gt”即可，同理，小于关系则使用$lt，例子如下：

　　BasicDBObject query  = new  BasicDBObject();
　　query.put( " number " ,  new  BasicDBObject( " $gt " ,  5 ));
　　DBCursor cursor  =  collection.find(query);
　　 while (cursor.hasNext()){
　　System.out.println(cursor.next());
　　}

 　　输出如下：

　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c2 " } ,  " number "  :  6 }
　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c3 " } ,  " number "  :  7 }
　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c4 " } ,  " number "  :  8 }
　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c5 " } ,  " number "  :  9 }
　　{ " _id "  : { " $oid "  :  " 4dc7f7b7bd0fb9a86c6c80c6 " } ,  " number "  :  10 }
　　也可以多个比较符号一起使用，比如要输出number > 5和number < 8的document,则如下：
　　BasicDBObject query  = new  BasicDBObject();
　　query.put( " number " ,  new  BasicDBObject( " $gt " ,  5 ).append( " $lt " ,  8 ));
　　DBCursor cursor  =  collection.find(query);
　　 while (cursor.hasNext()){
　　System.out.println(cursor.next());
　　}

 　　同样，如果是不等于的关系的话，可以使用$ne操作符，如下：

　　BasicDBObject query5  = new  BasicDBObject();
　　query5.put( " number " ,  new  BasicDBObject( " $ne " ,  8 ));
　　DBCursor cursor6  =  collection.find(query5);
　　 while (cursor6.hasNext()){
　　System.out.println(cursor6.next());
　　}

 　　以上输出number=8之外的所有document。

　　删除document

　　下面我们学习如何删除document，依然以上面的已插入的1-10的documents集合为例说明：

　　1) 删除第一个document

　　DBObject doc  =  collection.findOne();
　　collection.remove(doc);

 　　2) 删除指定的document

　　比如删除number=2的document,如下方法：

　　BasicDBObject document  = new  BasicDBObject();
　　document.put( " number " ,  2 );
　　collection.remove(document);

 　　要注意的是，如下的方法将只会删除number=3的document。

　　BasicDBObject document  = new  BasicDBObject();
　　document.put( " number " ,  2 );
　　document.put( " number " ,  3 );
　　collection.remove(document);

　　3) 使用in 操作符号指定删除document

　　下面的例子将同时删除number=4和number=5的document，使用的是in操作符

　　BasicDBObject query2  = new  BasicDBObject();
　　List list  = new  ArrayList();
　　list.add( 4 );
　　list.add( 5 );
　　query2.put( " number " ,  new  BasicDBObject( " $in " , list));
　　collection.remove(query2);

　　4) 使用“$gt”删除大于某个值的document

　　BasicDBObject query  = new  BasicDBObject();
　　query.put( " number " ,  new  BasicDBObject( " $gt " ,  9 ));
　　collection.remove(query);

　　以上会删除number=10的document。

　　5) 删除所有的document

　　DBCursor cursor  =  collection.find();
　　 while (cursor.hasNext()){
　　collection.remove(cursor.next());
　　}

　　保存图片到Mongodb

　　下面将讲解如何使用Java MongoDB GridFS API去保存图片等二进制文件到Monodb，关于Java MongoDB GridFS API的详细论述，请参考http://www.mongodb.org/display/DOCS/GridFS+Specification

　　1)保存图片

　　代码段如下：

　　String newFileName  = " mkyong-java-image " ;
　　File imageFile  = newFile( " c:\\JavaWebHosting.png " );
　　GridFS gfsPhoto  = new  GridFS(db,  " photo " );
　　GridFSInputFile gfsFile  =  gfsPhoto.createFile(imageFile);
　　gfsFile.setFilename(newFileName);
　　gfsFile.save();

　　这里，将c盘下的JavaWebHosting.png保存到mongodb中去，并命名为mkyong-java-image。

　　2) 读取图片信息

　　代码段如下

　　String newFileName  = " mkyong-java-image " ;
　　GridFS gfsPhoto  = new  GridFS(db,  " photo " );
　　GridFSDBFile imageForOutput  =  gfsPhoto.findOne(newFileName);
　　System.out.println(imageForOutput);

　　将会输出JSON格式的结果;

　　{
　　 " _id "  :
　　{
　　 " $oid "  :  " 4dc9511a14a7d017fee35746 "
　　} ,
　　 " chunkSize "  :  262144  ,
　　 " length "  :  22672  ,
　　 " md5 "  :  " 1462a6cfa27669af1d8d21c2d7dd1f8b "  ,
　　 " filename "  :  " mkyong-java-image "  ,
　　 " contentType "  :  null  ,
　　 " uploadDate "  :
　　{
　　 " $date "  :  " 2011-05-10T14:52:10Z "
　　} ,
　　 " aliases "  :  null
　　}

　　可以看到，输出的是文件的属性相关信息。


　　3) 输出已保存的所有图片

　　下面代码段，输出所有保存在photo命名空间下的图片信息：

　　GridFS gfsPhoto  = new  GridFS(db,  " photo " );
　　DBCursor cursor  =  gfsPhoto.getFileList();
　　 while (cursor.hasNext()){
　　System.out.println(cursor.next());
　　}

 　　4) 从数据库中读取一张图片并另存

　　下面的代码段，从数据库中读取一张图片并另存为另外一张图片到磁盘中

　　String newFileName  = " mkyong-java-image " ;
　　GridFS gfsPhoto  = new  GridFS(db,  " photo " );
　　GridFSDBFile imageForOutput  =  gfsPhoto.findOne(newFileName);
　　imageForOutput.writeTo( " c:\\JavaWebHostingNew.png " );

 　　5) 删除图片

　　String newFileName  = " mkyong-java-image " ;
　　GridFS gfsPhoto  = new  GridFS(db,  " photo " );
　　gfsPhoto.remove(gfsPhoto.findOne(newFileName));

 　　如何将JSON数据格式转化为DBObject格式

　　在mongodb中，可以使用com.mongodb.util.JSON类，将JSON格式的字符串转变为DBObject对象。MongoDB for JAVA驱动中提供了用于向数据库中存储普通对象的接口DBObject，当一个文档从MongoDB中取出时，它会自动把文档转换成DBObject接口类型，要将它实例化为需要的对象。比如：

　　{
　　 ' name '  :  ' mkyong ' ,
　　 ' age '  :  30
　　}

 　　这样的JSON格式字符串，转换方法为：

　　DBObject dbObject  = (DBObject) JSON.parse( " {'name':'mkyong', 'age':30} " );

 　　完整的代码如下：

　　packagecom.mkyong.core;
　　importjava.net.UnknownHostException;
　　importcom.mongodb.DB;
　　importcom.mongodb.DBCollection;
　　importcom.mongodb.DBCursor;
　　importcom.mongodb.DBObject;
　　importcom.mongodb.Mongo;
　　importcom.mongodb.MongoException;
　　importcom.mongodb.util.JSON;
　　 /**
　　* Java MongoDB : Convert JSON data to DBObject
　　*
　　 */
　　publicclass App {
　　publicstaticvoid main(String[] args){
　　 try {
　　Mongo mongo  = new  Mongo( " localhost " ,  27017 );
　　DB db  =  mongo.getDB( " yourdb " );
　　DBCollection collection  =  db.getCollection( " dummyColl " );
　　DBObject dbObject  = (DBObject) JSON
　　.parse( " {'name':'mkyong', 'age':30} " );
　　collection.insert(dbObject);
　　DBCursor cursorDoc  =  collection.find();
　　 while (cursorDoc.hasNext()){
　　System.out.println(cursorDoc.next());
　　}
　　System.out.println( " Done " );
　　} catch (UnknownHostException e){
　　e.printStackTrace();
　　} catch (MongoException e){
　　e.printStackTrace();
　　}
　　}
　　}

 　　则输出为：

　　{ " _id "  : { " $oid "  :  " 4dc9ebb5237f275c2fe4959f " } ,  " name "  :  " mkyong "  ,  " age "  :  30 }
　　Done

　　可以看到，将JSON格式的数据类型直接转换为mongodb中的文档类型并输出。

　　小结：

　　本文学习了如何使用Mongodb for JAVA驱动，对mongodb进行日常的数据库操作，比如增加，删除和修改，下一篇教程中，将指导学习Spring对mongodb的操作。

thundercat
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
使用Java操作mongoDB
wr456wr的博客
06-06 2350
使用Java操作mongoDB,对mongoDB进行增删改查等操作
主流NOSQL数据库之MongoDB快速入门
03-04
在本系列教程中，将分三部分指导对Mongodb的学习，在第一部分中，将简单介绍Mongodb的安装和基本使用方法，在第二部分中，将介绍Java对Mongodb的编程操作，在第三部分中，将介绍Spring对Mongodb的编程操作。...
<转>Mongodb快速入门之使用Java操作Mongodb
tianyestar
12-19 495
Mongodb快速入门之使用Java操作Mongodb 2011年06月20日00:00 it168网站原创 作者：廖煜嵘/译 编辑：董建伟 　　【IT168 专稿】在上一篇文章中，我们学习了Mongodb的安装和初步使用，在本文中，将学习如何使用Java去编程实现对Mongodb的操作。 　　HelloWorld程序 　　学习任何程序的第一步，都是编写HelloWor...
Mongodb的数据库简介、docker部署、操作语句以及java应用
最新发布
xingyuemengjin的博客
06-02 1406
本文主要介绍了mongodb的基础概念和特点，以及基于docker的mongodb部署方法，最后介绍了mongodb的常用数据库操作语句（增删改查等）以及java下的常用语句。
mongodb的java驱动包_mongodb在java驱动包下的操作(转)
weixin_39887386的博客
02-13 593
推荐几章很有用的文章java操作参考文档http://www.cnblogs.com/hoojo/archive/2011/06/02/2068665.htmlhttp://blog.csdn.net/java2000_wl/article/details/7982934http://www.111cn.net/jsp/55/51020.htmhttp://blog.csdn.net/mcpang...
Mongo中id介绍
草原孤狼的专栏
10-10 2354
好记忆不如按烂笔头 ，即便是最简单的，时间长了也难免会忘记，记下可以让你更明白。 2.6.6　_id和ObjectId MongoDB 中存储的文档必须有一个"_id" 键。这个键的值可以是任何类型的，默认是个ObjectId 对象。在一个集合里面，每个文档都有唯一的"_id" 值，来确保集合里面每个文档都能被唯一标识。如果有两个集合的话，两个集合可以都有一个值为123 的"_id"
MongoDB+Java强强联合篇
程序员Forlan的博客
07-11 1994
本篇内容主要分享在Java中如何操作MongoDB，主要有3种方式，会分别介绍基本的CRUD操作
MongoDB快速入门笔记(八)之MongoDB的java驱动操作代码讲解
09-02
在本篇快速入门笔记中，我们将深入学习如何使用Java驱动进行MongoDB的操作。 首先，要连接到MongoDB服务，我们需要创建`ServerAddress`对象，指定MongoDB服务器的地址（通常是“localhost”）和端口号（默认为27017...
Java操作MongoDB数据库方法详解
08-28
本文将详细介绍如何使用 Java 操作 MongoDB 数据库，包括连接、数据库操作以及 CRUD（Create、Read、Update、Delete）操作。 **一、Java 连接 MongoDB** 1. **连接单台 MongoDB** 在 Java 中，你可以使用 `Mongo`...
mongodb基础入门_动力节点Java学院整理
09-09
在本文中，我们将深入探讨 MongoDB 的基础入门知识，包括安装、启动以及基本的 CRUD (创建、读取、更新、删除) 操作。 首先，让我们了解 MongoDB 的核心概念。在 MongoDB 中，数据库是存储数据的逻辑单元，类似于...
mongoDB——java操作mongodb文档
热门推荐
09-10 1万+
上篇博客介绍了java操作mongoDB进行对文件的处理。现在来介绍一下对文档的处理。和对文件的处理一样，也是通过java驱动中提供的几个类相互作用完成的。这几个类分别是：       DBCollection类：指定数据库中指定集合的实例，提供了增删改查等一系列操作。在关系型数据库中，对数据的增删改查操作是建立在表的基础上的，在mongodb中是建立在集合的基础上进行的。       DBO
MongoDB学习（java版）
java学习相关内容
03-08 2301
mongodb系统学习笔记
(java) springboot操作mongodb的方式
qq_35573689的博客
02-08 1819
java操作mongodb 的方式有两种              1.继承 MongoRepository 这种方式比较简单。MongoRepository内部继承了部分curd操作。如果内部方法能满足需求的话，就是要继承它就可以。如果不可以的话，可以在接口中写自己的方法。MongoRepository内部的方法有：                 public abstract &lt;S e...
MongoDB详解（2）--java中的使用
ji_xin0721的博客
01-23 691
【代码】MongoDB详解（2）--java中的使用。
java mongodb_MongoDB Java CRUD示例教程
从零开始的教程世界
07-18 121
java mongodbWelcome to MongoDB Java Example Tutorial. Earlier we learned how to install MongoDB in Unix machines and executed some commands from terminal. Today we will look into the MongoDB Java Driv...
mongodb简介 mongo命令入门
wade1010的专栏
11-17 707
memcached redis kv数据库(key/value) mongodb 文档数据库,存储的是文档(Bson->json的二进制化). 特点:内部执行引擎为JS解释器, 把文档存储成bson结构,在查询时,转换为JS对象,并可以通过熟悉的js语法来操作. mongo和传统型数据库相比,最大的不同: 传统型数据库: 结构化数据, 定好了表结构后,每一行的内容,必是符合表结构的,就是说--列的个数,类型都一样. mongo文档型数据库: 表下的每篇文...
【MongoDB数据库】Java MongoDB CRUD Example
Larry的博客
12-15 422
上一篇我们讲了MongoDB 的命令入门初探，本篇blog将基于上一篇blog所建立的数据库和表完成一个简单的Java MongoDB CRUD Example，利用Java连接MongoDB数据库，并实现创建数据库、获取表、遍历表中的对象、对表中对象进行CRUD操作等例程。 1、下载MongoDB Java 支持驱动包 【gitHub下载地址】https://github.com/mo
MongoDB与Java(2) - 操作数据库
changyuanchen的博客
12-03 303
我们知道，MongoDB的三大基本元素是数据库,集合,文档,而这一章，我们将学习如何使用MongoDB Java Driver API来操作数据库。本章不会谈到所有的API,只是起一个抛砖引玉的方式。本章内容如下: 1. 数据库基本操作 2. 执行db.adminCommand命令   我们还是用代码来驱动讲解，而不是讲解来驱动代码。在本章中，甚至以后的章节中，都会沿用使用单元测试代码...
Java连接MongoDB，java对MongoDB的增删改查操作
LIJINGPO的博客
12-26 591
然后在下面创建lib文件夹（Folder）用于存放jar包；并且将名为mongo-java-driver-3.4.2.jar的jar包拷入后右键Build Path，导包的工作就完成了。**对Bson数据和Document的解释：**Mongo的insertMany和insertOne方法中后面需要的参数是Document类型的，而Document又继承自Bson。控制台出现下面内容证明连接成功。1、创建java项目。
mongoDB入门使用.pptx
07-13
"MongoDB是一个基于分布式文件存储的非关系型数据库，主要用于Web应用的数据存储，具有可扩展性、高性能和易部署的特点...对于Java开发者而言，MongoDB提供了Java驱动程序，使得在Java应用中集成MongoDB变得简单直接。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值