㈠ java面試中redis，mongodb類的，會問哪些問題，怎麼回答
1、可能會問nosql和關系型資料庫的區別：
優點：
1）成本：nosql資料庫簡單易部署，基本都是開源軟體，不需要像使用Oracle那樣花費大量成本購買使用，相比關系型資料庫價格便宜
2）查詢速度：nosql資料庫將數據存儲於緩存之中，關系型資料庫將數據存儲在硬碟中，自然查詢速度遠不及nosql資料庫
3）存儲數據的格式：nosql的存儲格式是key,value形式、文檔形式、圖片形式等等，所以可以存儲基礎類型以及對象或者是集合等各種格式，而資料庫則只支持基礎類型
4）擴展性：關系型資料庫有類似join這樣的多表查詢機制的限制導致擴展很艱難
缺點：
1）維護的工具和資料有限，因為nosql是屬於新的技術，不能和關系型資料庫10幾年的技術同日而語。
2）不提供對sql的支持，如果不支持sql這樣的工業標准，將產生一定用戶的學習和使用成本
3）不提供關系型資料庫對事物的處理
2、介紹下redis和mongodb：
自行google。
3、應用場景：
redis：
a.主要是做熱點數據緩存。
b.數據過期處理。
c.消息隊列等功能。
d.計數，例如投票等。
mongodb：
mongodb的主要目標是在鍵/值存儲方式（提供了高性能和高度伸縮性）以及傳統的RDBMS系統（豐富的功能）架起一座橋梁，集兩者的優勢於一身。mongo適用於以下場景：
a.網站數據：mongo非常適合實時的插入，更新與查詢，並具備網站實時數據存儲所需的復制及高度伸縮性。
b.緩存：由於性能很高，mongo也適合作為信息基礎設施的緩存層。在系統重啟之後，由mongo搭建的持久化緩存可以避免下層的數據源過載。
c.大尺寸、低價值的數據：使用傳統的關系資料庫存儲一些數據時可能會比較貴，在此之前，很多程序員往往會選擇傳統的文件進行存儲。
d.高伸縮性的場景：mongo非常適合由數十或者數百台伺服器組成的資料庫。
e.用於對象及JSON數據的存儲：mongo的BSON數據格式非常適合文檔格式化的存儲及查詢。
4、支持的數據類型:
內容比較多，自行將網上的信息整理一下。
㈡ 關於mongoDB的$or 怎麼用java實現
舉例：
public static void selectAll() throws Exception{
//第一：實例化mongo對象，連接mongodb伺服器 包含所有的資料庫
//默認構造方法，默認是連接本機，埠號，默認是27017
//相當於Mongo mongo =new Mongo("localhost",27017)
Mongo mongo =new Mongo();
//第二：連接具體的資料庫
//其中參數是具體資料庫的名稱，若伺服器中不存在，會自動創建
DB db=mongo.getDB("myMongo");
//第三：操作具體的表
//在mongodb中沒有表的概念，而是指集合
//其中參數是資料庫中表，若不存在，會自動創建
DBCollection collection=db.getCollection("user");
BasicDBList condList = new BasicDBList();
BasicDBObject cond = null;
String ageStr = "function (){return parseFloat(this.id) > 2 && parseFloat(this.id) <= 4};";
cond = new BasicDBObject();
cond.put("$where",ageStr);
Pattern pattern = Pattern.compile("^.*明.*$", Pattern.CASE_INSENSITIVE);
BasicDBObject query =new BasicDBObject();
query.put("name", pattern);
condList.add(query);
condList.add(cond);
BasicDBObject searchCond = new BasicDBObject();
searchCond.put("$or", condList);
//查詢操作
DBCursor cursor=collection.find(searchCond);
System.out.println("mongodb中的user表結果如下：");
while(cursor.hasNext()){
System.out.println(cursor.next());
}
}
㈢ 如何在Java中對MongoDB按日期進行查詢統計
方法一：通過構造BasicDBObject對象來進行查詢
[java] view plain
int startYear=2015,endYear=2016;
int startMonth=12,endMonth=1;
int startDay=1,endDay=1;
BasicDBObject query= new BasicDBObject("applydate", new BasicDBObject("$gte", new Date(startYear - 1900, startMonth - 1, startDay)).append("$lt", new Date(endYear - 1900, endMonth -1, endDay)));//因為無法確知當前月有多少天，所以就從當月的1號(包含)計到下月1號(不包含)
int iCount = cltApplies.find(query).count();
System.out.println(iCount);
經測試上述代碼執行完畢後iCount為9。也就是在2016-1-1至2016-1-31期間有9條記錄。
方法二：通過BasicDBObjectBuilder對象來查詢：
[java] view plain
int startYear=2016,endYear=2016;
int startMonth=1,endMonth=2;
int startDay=1,endDay=1;
BasicDBObject query= new BasicDBObject();
query.put("applydate", BasicDBObjectBuilder.start("$gte", new Date(startYear - 1900, startMonth - 1, startDay)).add("$lt", new Date(endYear - 1900, endMonth - 1, endDay)).get());
int iCount = cltApplies.find(query).count();
System.out.println(iCount);
上述代碼執行後iCount同樣為9。
注意：因為java.util.Date(year,month,day)這個構造函數中year是超出1900的年數，所以需要減去1900；month從0開始，所以需要減去1。這個問題容易被初學者忽視。
下面擴展地說一下如果要進行帶日期過濾條件的統計，該如何做。
前面的東西都相同，只是在統計的時候需要調用集合的distinct方法。如統計某個欄位不重復的值有哪些，可用如下寫法：
[java] view plain
int startYear=2016,endYear=2016;
int startMonth=1,endMonth=2;
int startDay=1,endDay=1;
BasicDBObject query= new BasicDBObject();
query.put("applydate", BasicDBObjectBuilder.start("$gte", new Date(startYear - 1900, startMonth - 1, startDay)).add("$lt", new Date(endYear - 1900, endMonth - 1, endDay)).get());
List<String> lstUserIds = cltApplies.distinct("userId", query);
System.out.println(lstUserIds.size());
上面這段代碼的執行結果為4。也就是在2016-1-1至2016-1-31之間出現了4個不同的userId。
㈣ 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更新整個文檔
上篇博客介紹了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如何構造鍵值對，以及一些條件表達式。
㈥ 如何用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();
}
}
}
㈦ 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();
}
}
}