MongoDB程序开发之使用Java驱动

转自：

 http://shensy.iteye.com/blog/1545335

在工作中使用到了MongoDB，平时也看了一些资料，感觉MongoDB官网内develop zone有个不错的manual，很多资料都可以查到，地址如下：http://www.mongodb.org/display/DOCS/Manual

 

另外，本blog主要记录一下使用mongodb java driver来访问数据库的一些总结。

 

 主要是由createMongoInstance()方法完成初始化工作。

Java代码  

1. protected static final Mongo mongoInstance = createMongoInstance();  
2.   
3. private static Mongo createMongoInstance() {  
4.         MongoOptions mo = new MongoOptions();  
5.         mo.socketKeepAlive=true;  
6.         mo.autoConnectRetry = true;  
7.         mo.maxAutoConnectRetryTime=10;  
8.         mo.connectionsPerHost = 40;  
9.         mo.connectTimeout = 20 * 1000;  
10.         mo.socketTimeout = 60 * 1000;  
11.         try {  
12.             if (DatabaseProject.DB_CONFIG.containsKey("mongodb.ips")) {  
13.                 return new Mongo(getServerAddrsFromConf("mongodb"),mo);  
14.             }  
15.             return new Mongo(new ServerAddress(DatabaseProject.DB_CONFIG.getString("mongodb.ip"), DatabaseProject.DB_CONFIG.getInt("mongodb.port")),mo);  
16.   
17.         } catch (Throwable e) {  
18.             DatabaseProject.LOGGER.error("Failed to init mongodb", e);  
19.             throw new ExceptionInInitializerError(e);  
20.         }  
21.     }  

  其中有一些数据库配置直接写在配置文件里了，在MongoJavaDriverDAO中初始化一部分数据：

 

Java代码  

1. public void insertCollData(){  
2.         //如果该collection不存在则会自动创建  
3.         DBCollection parentcoll = getCollection("ParentColl");  
4.         DBCollection childcoll = getCollection("ChildColl");  
5.         for(int i=0;i<1000;i++){  
6.             DBObject document = new BasicDBObject();  
7.             document.put("intData", 1000+i);  
8.             document.put("longData", System.currentTimeMillis());  
9.             document.put("strData", UUID.randomUUID().toString());  
10.             document.put("doubleData", 1.123+i);  
11.             document.put("createDate", new Date());  
12.             document.put("booleanData", true);  
13.             DBObject innerDoc = new BasicDBObject();  
14.             innerDoc.put("innertype", "string");  
15.             innerDoc.put("innerContent", "string"+i);  
16.             document.put("documentData", innerDoc);  
17.             parentcoll.insert(document);  
18.             DBObject childDocument = new BasicDBObject();  
19.             childDocument.put("parentId", document.get("_id"));  
20.             childDocument.put("createDate", new Date());  
21.             List list = new ArrayList();  
22.             list.add("str" + i%10);  
23.             list.add("str" + i%20);  
24.             list.add(new BasicDBObject("arr"+(i%10),(i%10)));  
25.             list.add(new BasicDBObject("arr"+(i%20),(i%20)));  
26.             childDocument.put("arrays",list);  
27.             childcoll.insert(childDocument);  
28.         }  
29.         System.out.println("ParentColl Count:"+parentcoll.count());  
30.         System.out.println("ChildColl Count:"+childcoll.count());  
31.     }  

 其中getCollection方法会获取集合，不存在的话会自动创建一个。getCollection方法如下：

 

Java代码  

1. public static DBCollection getCollection(String collectionName){  
2.     return getDB().getCollection(collectionName);  
3. }  

 现在创建了2个集合ParentColl、ChildColl，并初始化了数据。

查询相关方法：

 

Java代码  

1. /** 
2.      * 查询全部数据 
3.      */  
4.     public void findColl(){  
5.         coll = getCollection("ParentColl");  
6.         DBCursor cur = coll.find();  
7.         while(cur.hasNext()){  
8.             System.out.println(cur.next());  
9.         }  
10.         System.out.println("Count:"+coll.count());  
11.     }  
12.       
13.     /** 
14.      * 根据ObjectId查询 
15.      */  
16.     public void findById(String id){  
17.         coll = getCollection("ParentColl");  
18.         DBCursor cur = coll.find(new BasicDBObject("_id", new ObjectId(id)));//直接用string查不出来  
19.         while(cur.hasNext()){  
20.             System.out.println(cur.next());  
21.         }  
22.     }  
23.       
24.     /** 
25.      * And多条件查询 
26.      */  
27.     public void findByAndQuery(int intData,long longData){  
28.         coll = getCollection("ParentColl");  
29.         BasicDBObject query = new BasicDBObject();  
30.         query.put("intData", intData);  
31.         query.put("longData", longData);  
32.         System.out.println(coll.findOne(query));  
33.     }  
34.       
35.     /** 
36.      * OR多条件查询 
37.      */  
38.     public void findByORQuery(int lte,int gt,long longData){  
39.         coll = getCollection("ParentColl");  
40.         BasicDBObject query=new BasicDBObject();  
41.         BasicDBObject longdata = new BasicDBObject("longData", longData);  
42.         BasicDBObject intdata = new BasicDBObject("intData", new BasicDBObject().append("$gt", gt).append("$lte",lte));  
43.         BasicDBList cond=new BasicDBList();  
44.         cond.add(longdata);  
45.         cond.add(intdata);  
46.         query.put("$or", cond);  
47.         DBCursor cur = coll.find(query);  
48.         while(cur.hasNext()){  
49.             System.out.println(cur.next());  
50.         }  
51.     }  
52.       
53.     /** 
54.      * IN查询 
55.      */  
56.     public void findByINQuery(int value1,int value2){  
57.         coll = getCollection("ParentColl");  
58.         BasicDBObject query=new BasicDBObject();  
59.         BasicDBList cond=new BasicDBList();  
60.         cond.add(value1);  
61.         cond.add(value2);  
62.         query.put("intData",new BasicDBObject("$in", cond));  
63.         DBCursor cur = coll.find(query);  
64.         while(cur.hasNext()){  
65.             System.out.println(cur.next());  
66.         }  
67.     }  
68.       
69.     /** 
70.      * NOT查询 
71.      */  
72.     public void findByNotQuery(int value1,int value2){  
73.         coll = getCollection("ParentColl");  
74.         BasicDBObject query=new BasicDBObject();  
75.         BasicDBList cond=new BasicDBList();  
76.         cond.add(value1);  
77.         cond.add(value2);  
78.         query.put("intData",new BasicDBObject("$nin", cond));  
79.         System.out.println("Count:"+coll.find(query).count());  
80.     }  
81.       
82.     /** 
83.      * 获取结果集第一条 
84.      */  
85.     public void fetchFirstQuery(int value1,int value2){  
86.         coll = getCollection("ParentColl");  
87.         BasicDBList cond = new BasicDBList();  
88.         cond.add(value1);  
89.         cond.add(value2);  
90.         BasicDBObject query = new BasicDBObject().append("intData",new BasicDBObject("$nin",cond));  
91.         System.out.println(coll.findOne(query));  
92.     }  
93.       
94.     /** 
95.      * 查询文档部分列 
96.      */  
97.     public void querySomeKey(){  
98.         coll = getCollection("ParentColl");  
99.         DBCursor cur = coll.find(new BasicDBObject(),new BasicDBObject("intData",true));  
100.         while(cur.hasNext()){  
101.             System.out.println(cur.next());  
102.         }  
103.     }  
104.       
105.     /** 
106.      * 查询内嵌文档 
107.      */  
108.     public void queryInnerDocument(){  
109.         coll = getCollection("ParentColl");  
110.         BasicDBObject map = new BasicDBObject();  
111.         map.put("innertype","string");  
112.         map.put("innerContent","string0");  
113.         DBCursor cur = coll.find(new BasicDBObject("documentData",map));  
114.         while(cur.hasNext()){  
115.             System.out.println(cur.next());  
116.         }  
117.     }  
118.       
119.     /** 
120.      * 查询内嵌部分文档 
121.      */  
122.     public void querySubInnerDocument(){  
123.         coll = getCollection("ParentColl");       
124.         DBCursor cur = coll.find(new BasicDBObject("documentData.innerContent","string0"));  
125.         while(cur.hasNext()){  
126.             System.out.println(cur.next());  
127.         }  
128.     }  
129.       
130.     /** 
131.      * 查询分页文档 
132.      */  
133.     public void queryByPage(int skipNum,int pageNum){  
134.         coll = getCollection("ParentColl");  
135.         DBCursor cur = coll.find().skip(skipNum).limit(pageNum);  
136.         while(cur.hasNext()){  
137.             System.out.println(cur.next());  
138.         }  
139.     }  
140.       
141.     /** 
142.      * 查询文档某列是否存在 
143.      */  
144.     public void queryExists(){  
145.         coll = getCollection("ParentColl");  
146.         DBCursor cur = coll.find(new BasicDBObject("longData",new BasicDBObject("$exists",true)));  
147.         while(cur.hasNext()){  
148.             System.out.println(cur.next());  
149.         }  
150.     }  
151.       
152.     /** 
153.      * 查询文档排序 
154.      */  
155.     public void sortDocument(){  
156.         coll = getCollection("ParentColl");  
157.         DBCursor cur = coll.find().sort(new BasicDBObject("intData",-1));//1:asc / -1:desc  
158.         while(cur.hasNext()){  
159.             System.out.println(cur.next());  
160.         }  
161.     }  

补充distinct查询：

Java代码  

1. /** 
2. * 获取根据某元素做distinct查询. 
3. */  
4.   public void distinctKey(){  
5. coll = getCollection("ParentColl");  
6. List<String> list = coll.distinct("documentData.innertype");  
7. for(String str:list){  
8.     System.out.println(str);  
9. }  
10.   }  

不难发现主要用到BasicDBObject、BasicDBList、DBCursor这三个类。BasicDBObject好比一个map，好比使用json查询中的{} 。BasicDBList是个list，用于or，nin等条件查询。DBCursor用于遍历结果集。其实只要将对应的json查询使用这3个类转化一下，就能写出对应的java代码了。

 

更新相关：

 

Java代码  

1. /** 
2.      * 更新文档1 
3.      */  
4.     public void updateDocument(){  
5.         DB db = getDB();  
6.         //由于mongodb中使用连接池的原因,getLastError()需要再次从连接池中获取连接.  
7.         //保证update操作和getLastError()使用同一个连接.  
8.         db.requestStart();  
9.         coll = db.getCollection("ParentColl");  
10.         WriteResult result = coll.update(new BasicDBObject("intData",1100),new BasicDBObject("$set", new BasicDBObject("booleanData",false)));  
11.         System.out.println("update count:"+result.getN());  
12.         if(result.getLastError().ok()){//获取上次操作结果是否有错误.  
13.             System.out.println("update document success.");  
14.         }else{  
15.             System.out.println(result.getLastError().getErrorMessage());  
16.         }  
17.         db.requestDone();  
18.     }  
19.       
20.     /** 
21.      * 更新文档2 
22.      */  
23.     public void updateMultiDocument(){  
24.         DB db = getDB();  
25.         db.requestStart();  
26.         coll = db.getCollection("ParentColl");  
27.         //第三个参数:如果没有该文档是否创建,第四个参数:是否更新全部匹配条件的文档.  
28.         WriteResult result = coll.update(new BasicDBObject("booleanData",false),new BasicDBObject("$set", new BasicDBObject("booleanData",true)),false,true);  
29.         System.out.println("update count:"+result.getN());  
30.         if(result.getLastError().ok()){//获取上次操作结果是否有错误.  
31.             System.out.println("update document success.");  
32.         }else{  
33.             System.out.println(result.getLastError().getErrorMessage());  
34.         }  
35.         db.requestDone();  
36.     }  

 注意requestStart、requestDone方法保证使用同一个数据库连接。WriteResult记录更新结果。 

 

索引相关：

 

Java代码  

1. /** 
2.      * 创建唯一索引 
3.      */  
4.     public void createIndexes(){  
5.         coll = getCollection("ParentColl");  
6.         BasicDBObject index = new BasicDBObject();  
7.         index.put("intData",1);//1:asc / -1:desc  
8.         index.put("unique",true);//唯一索引  
9.         coll.createIndex(index);  
10.     }  
11.       
12.     /** 
13.      * 查询索引信息 
14.      */  
15.     public void getIndexes(){  
16.         coll = getCollection("ParentColl");  
17.         List<DBObject> indexInfo = coll.getIndexInfo();  
18.         System.out.println(indexInfo);  
19.     }  
20.       
21.     /** 
22.      * 删除索引信息 
23.      */  
24.     public void dropIndexes(){  
25.         coll = getCollection("ParentColl");  
26.         //删除的索引必须跟创建的索引名称\排序\是否唯一都相同才能删除  
27.         BasicDBObject index = new BasicDBObject();  
28.         index.put("intData",1);  
29.         index.put("unique",true);  
30.         coll.dropIndex(index);  
31.     }  

 对于文档可能还会对数组操作：

 

Java代码  

1. /** 
2.      * 取出文档中的数组 
3.      */  
4.     public void queryArray(){  
5.         coll = getCollection("ChildColl");  
6.         DBCursor cur = coll.find(new BasicDBObject(),new BasicDBObject("arrays",1));  
7.         while(cur.hasNext()){  
8.             BasicDBObject bo = (BasicDBObject)cur.next();  
9.             List<BasicDBObject> list = (List<BasicDBObject>)bo.get("arrays");  
10.             System.out.println(list.toString());  
11.         }  
12.     }  
13.       
14.     /** 
15.      * 查询数组内是否包含某元素 
16.      */  
17.     public void queryElementInArray(){  
18.         coll = getCollection("ChildColl");  
19.         BasicDBObject query = new BasicDBObject();  
20.         BasicDBObject obj = new BasicDBObject();  
21.         obj.put("arr0",0);  
22.         query.put("arrays", new BasicDBObject("$elemMatch",obj));  
23.         DBCursor cur = coll.find(query);  
24.         while(cur.hasNext()){  
25.             System.out.println(cur.next());  
26.         }  
27.     }  
28.       
29.     /** 
30.      * 数组内包含元素的值 
31.      */  
32.     public void queryElementArray(){  
33.         coll = getCollection("ChildColl");  
34.         BasicDBObject obj = new BasicDBObject();  
35.         obj.put("arrays", "str0");  
36.         obj.put("arrays.arr0",0);  
37.         obj.put("arrays.arr10",10);  
38.         DBCursor cur = coll.find(obj);  
39.         while(cur.hasNext()){  
40.             System.out.println(cur.next());  
41.         }  
42.     }  
43.       
44.     /** 
45.      * push(pushAll) array element 
46.      */  
47.     public void pushElementInArray(String _id){  
48.         DB db = getDB();  
49.         db.requestStart();  
50.         coll = getCollection("ChildColl");  
51.         //WriteResult result = coll.update(new BasicDBObject("_id", new ObjectId(_id)),new BasicDBObject("$push",new BasicDBObject("arrays",new BasicDBObject("arr99","99"))));  
52.         List<BasicDBObject> list=new ArrayList<BasicDBObject>();  
53.         list.add(new BasicDBObject("arr99",99));  
54.         list.add(new BasicDBObject("arr100",100));  
55.         WriteResult result = coll.update(new BasicDBObject("_id", new ObjectId(_id)),new BasicDBObject("$pushAll",new BasicDBObject("arrays",list)));  
56.         System.out.println("update count:"+result.getN());  
57.         if(result.getLastError().ok()){  
58.             System.out.println("update document success.");  
59.         }else{  
60.             System.out.println(result.getLastError().getErrorMessage());  
61.         }  
62.         db.requestDone();  
63.     }  
64.       
65.     /** 
66.      * pull(pullAll) array element 
67.      */  
68.     public void pullElementInArray(String _id){  
69.         DB db = getDB();  
70.         db.requestStart();  
71.         coll = getCollection("ChildColl");  
72.         List<BasicDBObject> list=new ArrayList<BasicDBObject>();  
73.         list.add(new BasicDBObject("arr99",99));  
74.         list.add(new BasicDBObject("arr100",100));  
75.         //WriteResult result = coll.update(new BasicDBObject("_id", new ObjectId(_id)),new BasicDBObject("$pull",new BasicDBObject("arrays",new BasicDBObject("arr100",100))));  
76.         WriteResult result = coll.update(new BasicDBObject("_id", new ObjectId(_id)),new BasicDBObject("$pullAll",new BasicDBObject("arrays",list)));  
77.         System.out.println("update count:"+result.getN());  
78.         db.requestDone();  
79.     }  
80.       
81.     /** 
82.      * pop array element(1,last;-1,first) 
83.      */  
84.     public void popElementInArray(String _id){  
85.         coll = getCollection("ChildColl");  
86.         WriteResult result = coll.update(new BasicDBObject("_id", new ObjectId(_id)),new BasicDBObject("$pop",new BasicDBObject("arrays",-1)));//1,last;-1,first  
87.         System.out.println("update count:"+result.getN());  
88.     }  
89.       
90.     /** 
91.      * addToSet And Each array element 
92.      */  
93.     public void addToSetAndEachElementInArray(String _id){  
94.         coll = getCollection("ChildColl");  
95.         List list = new ArrayList();  
96.         list.add("str0");  
97.         list.add("str1");  
98.         list.add(new BasicDBObject("arr99",99));  
99.         WriteResult result = coll.update(new BasicDBObject("_id", new ObjectId(_id)),new BasicDBObject("$addToSet",new BasicDBObject("arrays",new BasicDBObject("$each",list))));//1,last;-1,first  
100.         System.out.println("update count:"+result.getN());  
101.     }  
102.   
103. /** 
104.      * 按数组位置更新文档(查询条件需要包含更新内容，$为数组位置占位符，只更新匹配到的第一个文档.) 
105.      */  
106.     public void updatePositionInArray(String _id){  
107.         coll = getCollection("ChildColl");  
108.         WriteResult result = coll.update(new BasicDBObject("arrays.arr0", 100),new BasicDBObject("$set",new BasicDBObject("arrays.$.arr0",101)));  
109.         System.out.println("update count:"+result.getN());  
110.     }  

   以上都是一些基本的查询、更新操作，当然还有一些如map reduce和关联查询等复杂的方法，我将另写一篇blog总结一下。

 

参考文献包括：《mongodb权威指南》、《mongodb管理与开发精要》，另外文章开头提到的MongoDB官网内的develop zone也是很不错的资料来源。

PS：

mongodb driver在线API文档： http://api.mongodb.org/java/2.8.0/ （目前是2.8.0）